home *** CD-ROM | disk | FTP | other *** search
/ Netscape Plug-Ins Developer's Kit / Netscape_Plug-Ins_Developers_Kit.iso / CGIPERL / MACPERL / MSRCE418.HQX / Perl Source ƒ / MacPerl / MPAppleEvents.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-27  |  151.0 KB  |  6,012 lines
  1. /*********************************************************************
  2. Project    :    MacPerl                -    Real Perl Application
  3. File        :    MPAppleEvents.c    -
  4. Author    :    Matthias Neeracher
  5.  
  6. A lot of this code is borrowed from 7Edit written by
  7. Apple Developer Support UK
  8.  
  9. Language    :    MPW C
  10.  
  11. $Log: MPAppleEvents.c,v $
  12. Revision 1.2  1994/05/04  02:48:27  neeri
  13. Inline input.
  14. Fix deletions.
  15.  
  16. Revision 1.1  1994/02/27  22:59:44  neeri
  17. Initial revision
  18.  
  19. Revision 0.4  1993/08/28  00:00:00  neeri
  20. FormatCommand
  21.  
  22. Revision 0.3  1993/08/16  00:00:00  neeri
  23. DoScript
  24.  
  25. Revision 0.2  1993/05/30  00:00:00  neeri
  26. Support console Windows
  27.  
  28. Revision 0.1  1993/05/29  00:00:00  neeri
  29. Compiles correctly
  30.  
  31. *********************************************************************/
  32.  
  33. #include <AppleEvents.h>
  34. #include <LowMem.h>
  35. #include <Menus.h>
  36. #include <PLStringFuncs.h>
  37. #include <Scrap.h>
  38. #include <TextEdit.h>
  39. #include <AEObjects.h>
  40. #include <AEPackObject.h>
  41. #include <AERegistry.h>
  42. #include <AEStream.h>
  43. #include <AEBuild.h>
  44. #include <Resources.h>
  45. #include <String.h>
  46. #include <TFileSpec.h>
  47.  
  48. #include "MPGlobals.h"
  49. #include "MPUtils.h"
  50. #include "MPAEUtils.h"
  51. #include "MPWindow.h"
  52. #include "MPFile.h"
  53. #include "MPAppleEvents.h"
  54. #include "MPScript.h"
  55. #include "MPSave.h"
  56. #include "MPPreferences.h"
  57. #include "MPAEVTStream.h"
  58.  
  59. /* these should come from the registry */
  60.  
  61. #define         kAEStartedRecording  'rec1'
  62. #define         kAEStoppedRecording    'rec0'
  63. #define         kAEDontExecute         0x00002000
  64.  
  65. #define         pText                     'TEXT'
  66. #define     cSpot                 'cspt'
  67.  
  68. /*
  69.     Text Properties
  70. */
  71.  
  72. #define         pStringWidth            'pwid'
  73.  
  74. /*
  75.     Window Properties - See the Registry for Details
  76. */
  77.  
  78. #define     pPosition               'ppos'
  79. #define         pPageSetup                'PSET' /* One of ours - Not in registry */
  80. #define         pShowBorders            'PBOR' /* Another of ours */
  81.  
  82. #define         typeTPrint                'TPNT' /* A raw TPrint record - also one of ours */
  83.  
  84. /*
  85.     Error Codes
  86. */
  87.  
  88. #define         kAEGenericErr    -1799
  89.  
  90. static short   gBigBrother;
  91. static char    *gTypingBuffer;
  92. static short   gCharsInBuffer;
  93. static AEDesc  gTypingTargetObject;
  94.  
  95. pascal Boolean AllSelected(TEHandle te)
  96. {
  97.     return ((*te)->selStart == 0 && (*te)->selEnd == (*te)->teLength);
  98. }
  99.  
  100. #ifndef RUNTIME
  101.  
  102. /*-----------------------------------------------------------------------*/
  103. /**----------                         APPLE EVENT HANDLING         ---------------**/
  104. /*-----------------------------------------------------------------------*/
  105.  
  106. pascal OSErr GetTHPrintFromDescriptor(const AEDesc *sourceDesc, THPrint *result)
  107. {
  108.     OSErr   myErr;
  109.     Size    ptSize;
  110.     AEDesc  resultDesc;
  111.  
  112.     *result = nil;
  113.  
  114.     if (myErr = AECoerceDesc(sourceDesc,typeTPrint,&resultDesc))
  115.         return myErr;
  116.  
  117.     *result = (THPrint)NewHandle(sizeof(TPrint));
  118.  
  119.     PrOpen();
  120.     PrintDefault(*result);
  121.  
  122.     HLock((Handle)*result);
  123.  
  124.     GetRawDataFromDescriptor(&resultDesc, (Ptr)**result, sizeof(TPrint), &ptSize);
  125.  
  126.     HUnlock((Handle)*result);
  127.  
  128.     if ((ptSize<sizeof(TPrint)) || (PrValidate(*result))) {
  129.         myErr = errAECoercionFail;
  130.         DisposHandle((Handle)*result);
  131.         *result = nil;
  132.     }
  133.  
  134.     PrClose();
  135.  
  136.     if (resultDesc.dataHandle)
  137.         AEDisposeDesc(&resultDesc);
  138.  
  139.     return myErr;
  140. } /*GetTHPrintFromDescriptor*/
  141.  
  142. /*******************************************************************************/
  143. /*
  144.     Object Accessors - Utility Routines
  145. */
  146.  
  147. #if !defined(powerc) && !defined(__powerc)
  148. #pragma segment ObjectAccessors
  149. #endif
  150.  
  151. /*
  152.     Returns the WindowPtr of the window with title nameStr
  153.     or nil if there is no matching window.
  154. */
  155. pascal WindowPtr WindowNameToWindowPtr(StringPtr nameStr)
  156. {
  157.     WindowPtr theWindow;
  158.     Str255    windTitle;
  159.  
  160.     theWindow = (WindowPtr)LMGetWindowList();
  161.     /*
  162.         iterate through windows - we use WindowList 'cos we could
  163.         have made the window invisible and  we lose it - so we
  164.         can't set it back to visible!!
  165.     */
  166.     while (theWindow) {
  167.         GetWTitle(theWindow, windTitle);
  168.         if (EqualString(windTitle,
  169.                              nameStr,
  170.                                         false,
  171.                                         true))     /* ignore case, don't ignore diacriticals */
  172.             return theWindow;
  173.       theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  174.     }
  175.  
  176.     return theWindow;
  177. }    /* WindowNameToWindowPtr */
  178.  
  179. pascal WindowPtr GetWindowPtrOfNthWindow(short index)
  180. /* returns a ptr to the window with the given index
  181.   (front window is 1, behind that is 2, etc.).  if
  182.   there's no window with that index (inc. no windows
  183.   at all), returns nil.
  184. */
  185. {
  186.   WindowPtr theWindow;
  187.  
  188.     theWindow = (WindowPtr)LMGetWindowList();
  189.  
  190.     /* iterate through windows */
  191.  
  192.     while (theWindow) {
  193.         if (--index <= 0)
  194.             return theWindow;
  195.  
  196.       theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  197.     }
  198.  
  199.     return nil;
  200. }    /* GetWindowPtrOfNthWindow */
  201.  
  202. pascal short CountWindows(void)
  203. {
  204.     WindowPtr theWindow;
  205.     short     index;
  206.  
  207.     index = 0;
  208.     theWindow = (WindowPtr)LMGetWindowList();
  209.  
  210.     /* iterate through windows */
  211.  
  212.     while (theWindow) {
  213.         index++;
  214.         theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  215.     }
  216.  
  217.     return index;
  218. } /*CountWindows*/
  219.  
  220. #endif
  221.  
  222. /**-----------------------------------------------------------------------
  223.         Name:         DoOpenApp
  224.         Purpose:        Called on startup, creates a new document.
  225.     -----------------------------------------------------------------------**/
  226.  
  227. #if !defined(powerc) && !defined(__powerc)
  228. #pragma segment Main
  229. #endif
  230.  
  231. pascal OSErr DoOpenApp(const AppleEvent *message, AppleEvent *reply, long refcon)
  232. {
  233.     if (gRuntimeScript)
  234.         return DoScript(message, reply, refcon);
  235.  
  236.     return noErr;
  237. }
  238.  
  239. /**-----------------------------------------------------------------------
  240.         Name:         DoOpenDocument
  241.         Purpose:        Open all the documents passed in the Open AppleEvent.
  242. -----------------------------------------------------------------------**/
  243.  
  244. #if !defined(powerc) && !defined(__powerc)
  245. #pragma segment Main
  246. #endif
  247.  
  248. pascal OSErr DoOpenDocument(const AppleEvent *message, AppleEvent *reply, long refcon)
  249. {
  250.     long        index;
  251.     long        itemsInList;
  252.     AEKeyword   keywd;
  253.     OSErr       err;
  254.     OSErr       ignoreErr;
  255.     AEDescList  docList;
  256.     long        actSize;
  257.     DescType    typeCode;
  258.     FSSpec      theFSSpec;
  259.     EventRecord    ev;
  260.     DocType        type;
  261.  
  262.     if (gRuntimeScript)
  263.         return DoScript(message, reply, refcon);
  264.     
  265.     /* open the specified documents */
  266.  
  267.     docList.dataHandle = nil;
  268.  
  269.     err = AEGetParamDesc(message, keyDirectObject, typeAEList, &docList);
  270.  
  271.     if (err==noErr)
  272.         err = AECountItems( &docList, &itemsInList) ;
  273.     else
  274.       itemsInList = 0;
  275.  
  276.     if (itemsInList) {
  277.         err =
  278.             AEGetNthPtr(&docList, 1, typeFSS, &keywd, &typeCode, (Ptr)&theFSSpec, sizeof(theFSSpec), &actSize);
  279.         
  280.         if (!err) {
  281.             type = GetDocType(&theFSSpec);
  282.             
  283.             GetNextEvent(0, &ev);
  284.         
  285.             switch (type) {
  286.             case kPlainTextDoc:
  287.             case kOldRuntime6Doc:
  288.             case kRuntime6Doc:
  289.             case kRuntime7Doc:
  290.                 if (!(ev.modifiers & optionKey) != gPerlPrefs.runFinderOpens)
  291.                     break;
  292.                 if (refcon != -1)
  293.                     break;
  294.                     
  295.                 err = DoScript(message, reply, 0);
  296.                     
  297.                 goto done;
  298.             }
  299.         }
  300.     }
  301.  
  302.     for (index = 1; index <= itemsInList; index++)
  303.         if (err==noErr) {
  304.             err = AEGetNthPtr( &docList, index, typeFSS, &keywd, &typeCode,
  305.                                                  (Ptr)&theFSSpec, sizeof(theFSSpec), &actSize ) ;
  306.             if (err==noErr)
  307.                 switch (type = GetDocType(&theFSSpec)) {
  308.                 case kUnknownDoc:
  309.                     break;
  310.                 case kPreferenceDoc:
  311.                     OpenPreferenceFile(&theFSSpec);
  312.                     break;
  313.                 case kPlainTextDoc:
  314.                 case kOldRuntime6Doc:
  315.                 case kScriptDoc:
  316.                 case kRuntime6Doc:
  317.                 case kRuntime7Doc:
  318.                 default:
  319.                       err = OpenOld(theFSSpec, type);
  320.                     break;
  321.                 }
  322.         }
  323.  
  324. done:    
  325.   if (docList.dataHandle)
  326.         ignoreErr = AEDisposeDesc(&docList);
  327.  
  328.     return err;
  329. }
  330.  
  331. /**-----------------------------------------------------------------------
  332.         Name:         MyQuit
  333.         Purpose:        Quit event received- exit the program.
  334.     -----------------------------------------------------------------------**/
  335.  
  336. #if !defined(powerc) && !defined(__powerc)
  337. #pragma segment Main
  338. #endif
  339.  
  340. pascal OSErr MyQuit(const AppleEvent *message, const AppleEvent *reply, long refcon)
  341. {
  342. #if !defined(powerc) && !defined(__powerc)
  343. #pragma unused (reply,refcon)
  344. #endif
  345.  
  346.     DescType saveOpt;
  347.     OSErr    tempErr;
  348.     OSErr    myErr;
  349.     DescType returnedType;
  350.     long     actSize;
  351.  
  352.     saveOpt = kAEAsk; /* the default */
  353.     tempErr = AEGetParamPtr(message,
  354.                                     keyAESaveOptions,
  355.                                     typeEnumerated,
  356.                                     &returnedType,
  357.                                     (Ptr)&saveOpt,
  358.                                     sizeof(saveOpt),
  359.                                     &actSize);
  360.  
  361.     if (saveOpt != kAENo)
  362.         myErr = AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  363.  
  364.     if (myErr == noErr)
  365.         DoQuit(saveOpt);
  366.  
  367.     return myErr;
  368. }
  369.  
  370. /**-----------------------------------------------------------------------
  371.         Name:         DoAppleEvent
  372.         Purpose:        Process and despatch the AppleEvent
  373.     -----------------------------------------------------------------------**/
  374.  
  375. #if !defined(powerc) && !defined(__powerc)
  376. #pragma segment Main
  377. #endif
  378.  
  379. pascal void DoAppleEvent(EventRecord theEvent)
  380. {
  381.   OSErr err;
  382.  
  383.   /*should check for your own event message types here - if you have any*/
  384.  
  385.     err = AEProcessAppleEvent(&theEvent);
  386. }
  387.  
  388. #ifndef RUNTIME
  389.  
  390. /**-----------------------------------------------------------------------
  391.         Name:         MakeSelfAddress
  392.         Purpose:        Builds an AEAddressDesc for the current process
  393.     -----------------------------------------------------------------------**/
  394.  
  395. pascal OSErr MakeSelfPSN(ProcessSerialNumber *selfPSN)
  396. {
  397.     selfPSN->highLongOfPSN = 0;
  398.     selfPSN->lowLongOfPSN  = kCurrentProcess;
  399.     
  400.     return noErr;
  401. }
  402.  
  403. pascal OSErr MakeSelfAddress(AEAddressDesc *selfAddress)
  404. {
  405.       ProcessSerialNumber procSerNum;
  406.  
  407.     MakeSelfPSN(&procSerNum);
  408.  
  409.     return
  410.         AECreateDesc(
  411.             typeProcessSerialNumber,
  412.             (Ptr)&procSerNum,
  413.             sizeof(procSerNum),
  414.             selfAddress);
  415. } /* MakeSelfAddress */
  416.  
  417. #endif
  418.  
  419. /**--------------------------------------------------------------------
  420.     Name :         SendAESetObjProp
  421.     Function :     Creates a property object from an object,
  422.                     a property type and its data and sends it to
  423.                     the requested address, and cleans up zapping params too
  424.     --------------------------------------------------------------------**/
  425.  
  426. pascal OSErr SendAESetObjProp(
  427.     AEDesc        *theObj,
  428.     DescType      theProp,
  429.     AEDesc        *theData,
  430.     AEAddressDesc *toWhom)
  431. {
  432.     AEDesc     propObjSpec;
  433.     AppleEvent myAppleEvent;
  434.     AppleEvent defReply;
  435.     OSErr      myErr;
  436.     OSErr      ignoreErr;
  437.     AEDesc     theProperty;
  438.  
  439.     /* create an object spec that represents the property of the given object */
  440.  
  441.     myErr = AECreateDesc(typeType, (Ptr)&theProp, sizeof(theProp), &theProperty);
  442.     if (myErr==noErr)
  443.         myErr =
  444.             CreateObjSpecifier(
  445.                 cProperty,
  446.                 theObj,
  447.                 formPropertyID,
  448.                 &theProperty,
  449.                 true,
  450.                 &propObjSpec);
  451.  
  452.     /* create event */
  453.  
  454.     if (myErr==noErr)
  455.         myErr =
  456.             AECreateAppleEvent(
  457.                 kAECoreSuite,
  458.                 kAESetData,
  459.                 toWhom,
  460.                 0,
  461.                 0,
  462.                 &myAppleEvent);
  463.  
  464.     /* add prop obj spec to the event */
  465.  
  466.     if (myErr==noErr)
  467.         myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, &propObjSpec);
  468.  
  469.     /* add prop data to the event */
  470.  
  471.     if (myErr==noErr)
  472.         myErr = AEPutParamDesc(&myAppleEvent, keyAEData, theData);
  473.  
  474.     /* send event */
  475.  
  476.     if (myErr==noErr)
  477.         myErr =
  478.             AESend(
  479.                 &myAppleEvent,
  480.                 &defReply,
  481.                 kAENoReply+kAEAlwaysInteract,
  482.                 kAENormalPriority,
  483.                 kAEDefaultTimeout,
  484.                 nil,
  485.                 nil);
  486.  
  487.     if (myAppleEvent.dataHandle)
  488.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  489.  
  490.     if (&propObjSpec.dataHandle)
  491.       ignoreErr = AEDisposeDesc(&propObjSpec);
  492.  
  493.     if (theData->dataHandle)
  494.         ignoreErr = AEDisposeDesc(theData);
  495.  
  496.     if (toWhom->dataHandle)
  497.         ignoreErr = AEDisposeDesc(toWhom);
  498.  
  499.     return myErr;
  500. }    /* SendAESetObjProp */
  501.  
  502. /*----------------------------------------------------------------------------------------------*/
  503. /*
  504.     Private AEObject definitions
  505. */
  506. #if !defined(powerc) && !defined(__powerc)
  507. #pragma segment AECommandHandlers
  508. #endif
  509.  
  510. #define typeMyAppl       'BAPP'    /* sig of my private token type for the app     - appToken   */
  511. #define typeMyWndw         'BWIN'    /* sig of my private token type for windows     - windowToken   */
  512. #define typeMyText           'BTXT'    /* sig of my private token type for text        - textToken     */
  513. #define typeMyTextProp   'BPRP'    /* sig of my private token type for text properties    - textPropToken */
  514. #define typeMyWindowProp 'WPRP'    /* sig of my private token type for window properties  - windowPropToken */
  515. #define typeMyApplProp   'APRP'    /* sig of my private token type for appl properties    - applPropToken */
  516. #define typeMyMenu       'MTKN'    /* sig of my private token type for menus       - menuToken  */
  517. #define typeMyMenuItem   'ITKN'    /* sig of my private token type for menus       - menuItemToken  */
  518. #define typeMyMenuProp   'MPRP'    /* sig of my private token type for menu properties - menuPropToken  */
  519. #define typeMyItemProp   'IPRP'    /* sig of my private token type for menu item properties  - menuItemPropToken  */
  520.  
  521. /* These are entirely private to our app - used only when resolving the object specifier */
  522.  
  523. typedef    ProcessSerialNumber appToken;
  524.  
  525. struct applPropToken{
  526.     appToken tokenApplToken;
  527.     DescType tokenApplProperty;
  528. };
  529.  
  530. typedef struct applPropToken applPropToken;
  531.  
  532. typedef    WindowPtr WindowToken;
  533.  
  534. struct windowPropToken{
  535.         WindowToken tokenWindowToken;
  536.         DescType    tokenProperty;
  537.     };
  538.  
  539. typedef struct windowPropToken windowPropToken;
  540.  
  541. struct TextToken{
  542.         WindowPtr tokenWindow;
  543.         short     tokenOffset;
  544.         short     tokenLength;
  545.     };
  546.  
  547. typedef struct TextToken TextToken;
  548.  
  549. struct textPropToken{
  550.         TextToken propertyTextToken;
  551.         DescType  propertyProperty;
  552.     };
  553.  
  554. typedef struct textPropToken textPropToken;
  555.  
  556. /* Tokens related to menus */
  557.  
  558. struct MenuToken {
  559.     MenuHandle theTokenMenu;
  560.     short      theTokenID;
  561. };
  562.  
  563. typedef struct MenuToken MenuToken;
  564.  
  565. struct MenuItemToken {
  566.     MenuToken  theMenuToken;
  567.     short      theTokenItem;
  568. };
  569.  
  570. typedef struct MenuItemToken MenuItemToken;
  571.  
  572. struct MenuPropToken {
  573.     MenuToken  theMenuToken;
  574.     DescType   theMenuProp;
  575. };
  576.  
  577. typedef struct MenuPropToken MenuPropToken;
  578.  
  579. struct MenuItemPropToken {
  580.     MenuItemToken  theItemToken;
  581.     DescType       theItemProp;
  582. };
  583.  
  584. typedef struct MenuItemPropToken MenuItemPropToken;
  585.  
  586. #ifndef RUNTIME
  587.  
  588. /*
  589.     Name: GotRequiredParams
  590.     Function: Checks all parameters defined as 'required' have been read
  591. */
  592. pascal OSErr GotRequiredParams(const AppleEvent *theAppleEvent)
  593. {
  594.     OSErr    myErr;
  595.     DescType returnedType;
  596.     Size     actSize;
  597.  
  598.     /* look for the keyMissedKeywordAttr, just to see if it's there */
  599.  
  600.     myErr =
  601.         AEGetAttributePtr(
  602.             theAppleEvent,
  603.             keyMissedKeywordAttr,
  604.             typeWildCard,
  605.             &returnedType,
  606.             nil,
  607.             0,
  608.             &actSize);
  609.  
  610.     if (myErr == errAEDescNotFound)
  611.         return noErr;            /* attribute not there means we got all req params */
  612.     else
  613.         if (myErr == noErr)
  614.             return errAEParamMissed;        /* attribute there means missed at least one */
  615.         else
  616.             return myErr;        /* some unexpected arror in looking for the attribute */
  617. }    /* GotReqiredParams */
  618.  
  619. /**--------------------------------------------------------------------
  620.     Name : SetSelectionOfAppleEventDirectObject
  621.     Function : Resolves the Direct Object into a text token and
  622.                          sets the selection of the specified document to that
  623.                          specified in the direct object.
  624.                          Returns the doc and TEHandle chosen.
  625.     --------------------------------------------------------------------**/
  626.  
  627. pascal OSErr SetSelectionOfAppleEventDirectObject(
  628.     const AppleEvent *theAppleEvent,
  629.     DPtr             *theDocument,
  630.     TEHandle         *theHTE)
  631. {
  632.     OSErr     myErr;
  633.     DescType  returnedType;
  634.     long      actSize;
  635.     TextToken myTextToken;
  636.     OSErr     paramErr;
  637.     WindowPtr fWin;
  638.  
  639.     paramErr =
  640.         AEGetParamPtr(
  641.             theAppleEvent,
  642.             keyDirectObject,
  643.             typeMyText,
  644.             &returnedType,
  645.             (Ptr)&myTextToken,
  646.             sizeof(myTextToken),
  647.             &actSize);
  648.  
  649.     myErr = GotRequiredParams(theAppleEvent);
  650.  
  651.     /* now let's work on the direct object, if any */
  652.  
  653.     if (paramErr == errAEDescNotFound) {
  654.         /* no direct object; check we have a window */
  655.  
  656.         fWin = FrontWindow();
  657.  
  658.         if (fWin == nil)
  659.             return -1700; /* Generic Err */
  660.  
  661.         *theDocument = DPtrFromWindowPtr(fWin);
  662.         *theHTE      = (*theDocument)->theText;
  663.     }
  664.  
  665.     if (paramErr == noErr)  {
  666.         /* got a text token */
  667.  
  668.         *theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  669.         *theHTE      = (*theDocument)->theText;
  670.  
  671.         TESetSelect(
  672.             myTextToken.tokenOffset-1,
  673.             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  674.             *theHTE);
  675.  
  676.     }
  677.  
  678.     if ((paramErr!=noErr) &&
  679.          (paramErr!=errAEDescNotFound)
  680.     ) {
  681.          *theDocument = DPtrFromWindowPtr(FrontWindow());
  682.          *theHTE      = (*theDocument)->theText;
  683.      }
  684.  
  685.     return myErr;
  686.  
  687. } /* SetSelectionOfAppleEventDirectObject */
  688.  
  689. /**--------------------------------------------------------------------
  690.     Name             : SetSelectionOfAppleEventObject
  691.     Function     : Resolves the whatObject type of the AppleEvent into a text
  692.                       token and sets the selection to be that specified in the
  693.                       text token.
  694.                       Returns the doc and TEHandle chosen.
  695.     --------------------------------------------------------------------**/
  696.  
  697. pascal OSErr SetSelectionOfAppleEventObject(
  698.     OSType            whatObject,
  699.     const AppleEvent *theAppleEvent,
  700.     DPtr             *theDocument,
  701.     TEHandle         *theHTE)
  702. {
  703.     DescType   returnedType;
  704.     long       actSize;
  705.     TextToken  myTextToken;
  706.     OSErr      paramErr;
  707.  
  708.     paramErr  =
  709.         AEGetParamPtr(
  710.             theAppleEvent,
  711.             whatObject,
  712.             typeMyText,
  713.             &returnedType,
  714.             (Ptr)&myTextToken,
  715.             sizeof(myTextToken),
  716.             &actSize);
  717.  
  718.     if (paramErr == noErr) {
  719.         /* got a text token */
  720.  
  721.         *theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  722.         *theHTE      = (*theDocument)->theText;
  723.  
  724.         TESetSelect(
  725.             myTextToken.tokenOffset-1,
  726.             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  727.             *theHTE);
  728.     }
  729.  
  730.     return paramErr;
  731. } /* SetSelectionOfAppleEventObject */
  732.  
  733. #endif
  734.  
  735. pascal void EnforceMemory(DPtr theDocument, TEHandle theHTE)
  736. {
  737.     if (theDocument->kind != kDocumentWindow && (*theHTE)->teLength > theDocument->u.cons.memory) {
  738.         short    obulus =    (*theHTE)->teLength - theDocument->u.cons.memory;
  739.         short saveStart;
  740.         short    saveEnd;
  741.         Ptr    search = *(*theHTE)->hText;
  742.         short rest   = theDocument->u.cons.memory;
  743.         
  744.         while (search[obulus-1] != '\n' && rest--)
  745.             ++obulus;
  746.             
  747.         saveStart    =    (*theHTE)->selStart - obulus;
  748.         saveEnd        =    (*theHTE)->selEnd      - obulus;
  749.         
  750.         TESetSelect(0, obulus, theHTE);
  751.         TEDelete(theHTE);
  752.         TESetSelect(saveStart < 0 ? 0 : saveStart, saveEnd < 0 ? 0 : saveEnd, theHTE);
  753.         
  754.         if (theDocument->u.cons.fence < 32767)
  755.             theDocument->u.cons.fence    -=    obulus;
  756.     }
  757. }
  758.  
  759. #ifndef RUNTIME
  760.  
  761. /* -----------------------------------------------------------------------
  762.         Name:         DoCopyEdit
  763.         Purpose:        Performs a copy text operation on the text selection specified
  764.                         by the appleEvent direct object (if any)
  765.      -----------------------------------------------------------------------**/
  766.  
  767. pascal OSErr DoCopyEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refCon)
  768. {
  769. #if !defined(powerc) && !defined(__powerc)
  770. #pragma unused (reply,refCon)
  771. #endif
  772.  
  773.     OSErr    myErr;
  774.     TEHandle theHTE;
  775.     DPtr     theDocument;
  776.  
  777.     /*
  778.             Here we extract the information about what to copy from the
  779.             directObject - if any
  780.     */
  781.  
  782.     if (myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent,&theDocument,&theHTE))
  783.         return myErr;
  784.  
  785.     myErr = (OSErr) ZeroScrap();
  786.     TECopy(theHTE);
  787.     TEToScrap();
  788.  
  789.     if (myErr)
  790.         return myErr;
  791.  
  792.     if (!SetSelectionOfAppleEventObject(
  793.         keyAEContainer,
  794.         theAppleEvent,
  795.         &theDocument,
  796.         &theHTE)
  797.     ) {
  798.         if (theDocument->kind == kDocumentWindow) {
  799.             DoTEPasteSectionRecalc(theDocument);
  800.         } else if (!theDocument->u.cons.selected || (*theHTE)->selStart < theDocument->u.cons.fence) {
  801.             SysBeep(1);
  802.             
  803.             return errAEEventNotHandled;
  804.         }
  805.             
  806.         TEFromScrap();
  807.         TEPaste(theHTE);
  808.         EnforceMemory(theDocument, theHTE);
  809.         AdjustScrollbars(theDocument, false);
  810.         DrawPageExtras(theDocument);
  811.             
  812.         theDocument->dirty = true;
  813.     }
  814.  
  815.     return noErr;
  816. } /* DoCopyEdit */
  817.  
  818. /* -----------------------------------------------------------------------
  819.         Name:             DoCutEdit
  820.         Purpose:        Performs a cut text operation on the current text selection
  821.      -----------------------------------------------------------------------**/
  822.  
  823. pascal OSErr DoCutEdit(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  824. {
  825. #if !defined(powerc) && !defined(__powerc)
  826. #pragma unused (reply,refCon)
  827. #endif
  828.  
  829.     OSErr    myErr;
  830.     TEHandle theHTE;
  831.     DPtr     theDocument;
  832.  
  833.     if (myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent,&theDocument,&theHTE))
  834.         return myErr;
  835.  
  836.     if (theDocument->kind == kDocumentWindow) {
  837.         DoTECutSectionRecalc(theDocument);
  838.         
  839.         theDocument->dirty = true;
  840.     } else if (!theDocument->u.cons.selected || (*theHTE)->selStart < theDocument->u.cons.fence) {
  841.         if (AllSelected(theHTE)) {
  842.             if (theDocument->u.cons.fence < 32767)
  843.                 theDocument->u.cons.fence = 0;
  844.         } else {
  845.             SysBeep(1);
  846.         
  847.             return DoCopyEdit(theAppleEvent, reply, refCon);
  848.         }
  849.     }
  850.  
  851.     myErr = (OSErr) ZeroScrap();
  852.     TECut(theHTE);
  853.     TEToScrap();
  854.     AdjustScrollbars(theDocument, false);
  855.     DrawPageExtras(theDocument);
  856.  
  857.     return myErr;
  858. } /* DoCutEdit */
  859.  
  860. /* -----------------------------------------------------------------------
  861.         Name:         DoPasteEdit
  862.         Purpose:        Performs a paste text operation on the text selection specified
  863.                         by the appleEvent direct object (if any)
  864.      -----------------------------------------------------------------------**/
  865.  
  866. pascal OSErr DoPasteEdit(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  867. {
  868. #if !defined(powerc) && !defined(__powerc)
  869. #pragma unused (reply,refCon)
  870. #endif
  871.  
  872.     OSErr    myErr;
  873.     TEHandle theHTE;
  874.     DPtr     theDocument;
  875.  
  876.     if (myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent, &theDocument, &theHTE))
  877.         return myErr;
  878.  
  879.     if (theDocument->kind == kDocumentWindow) {
  880.         DoTEPasteSectionRecalc(theDocument);
  881.     } else if (!theDocument->u.cons.selected || (*theHTE)->selStart < theDocument->u.cons.fence) {
  882.         SysBeep(1);
  883.             
  884.         return errAEEventNotHandled;
  885.     }
  886.     
  887.     TEFromScrap();
  888.     TEPaste(theHTE);
  889.     EnforceMemory(theDocument, theHTE);
  890.     AdjustScrollbars(theDocument, false);
  891.     DrawPageExtras(theDocument);
  892.         
  893.     theDocument->dirty = true;
  894.  
  895.     return noErr;
  896. } /* DoPasteEdit */
  897.  
  898. /* -----------------------------------------------------------------------
  899.         Name:         DoDeleteEdit
  900.         Purpose:        Performs a delete text operation on the selection specified
  901.                         by the appleEvent direct object (if any)
  902.      -----------------------------------------------------------------------**/
  903.  
  904. pascal OSErr DoDeleteEdit(const AppleEvent *theAppleEvent, AppleEvent *reply, long refcon)
  905. {
  906. #if !defined(powerc) && !defined(__powerc)
  907. #pragma unused (reply,refcon)
  908. #endif
  909.  
  910.     OSErr     myErr;
  911.     TEHandle theHTE;
  912.     DPtr     theDocument;
  913.  
  914.     if (myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent, &theDocument, &theHTE))
  915.         return myErr;
  916.  
  917.     if (theDocument->kind == kDocumentWindow) {
  918.         DoTEDeleteSectionRecalc(theDocument);
  919.     } else if (!theDocument->u.cons.selected || (*theHTE)->selStart < theDocument->u.cons.fence) {
  920.         if (AllSelected(theHTE)) {
  921.             if (theDocument->u.cons.fence < 32767)
  922.                 theDocument->u.cons.fence = 0;
  923.         } else {
  924.             SysBeep(1);
  925.                 
  926.             return errAEEventNotHandled;
  927.         }
  928.         theDocument->u.cons.fence = 0;
  929.     }
  930.     
  931.     TEDelete(theHTE);
  932.     AdjustScrollbars(theDocument, false);
  933.     DrawPageExtras(theDocument);
  934.     theDocument->dirty = true;
  935.  
  936.     return noErr;
  937. } /*DoDeleteEdit*/
  938.  
  939. #endif
  940.  
  941. void RecalcFontInfo(TEHandle te)
  942. {
  943.     TEPtr        t;
  944.     short        oldFont;
  945.     short        oldSize;
  946.     FontInfo    info;
  947.  
  948.     HLock((Handle) te);
  949.  
  950.     t             = *te;
  951.     oldFont    =    t->inPort->txFont;
  952.     oldSize    =    t->inPort->txSize;
  953.  
  954.     SetPort(t->inPort);
  955.     TextFont(t->txFont);
  956.     TextSize(t->txSize);
  957.     GetFontInfo(&info);
  958.     TextFont(oldFont);
  959.     TextSize(oldSize);
  960.  
  961.     t->lineHeight    =    info.ascent+info.descent+info.leading;
  962.     t->fontAscent    =    info.ascent;
  963.     InvalRect(&t->viewRect);
  964.     HUnlock((Handle) te);
  965.  
  966.     TECalText(te);
  967. }
  968.  
  969. #ifndef RUNTIME
  970.  
  971. /* -----------------------------------------------------------------------
  972.         Name:         SetWindowProperty
  973.         Purpose:        Sets the window property specified in theWindowPropToken to
  974.                         be that supplied in dataDesc.
  975.      -----------------------------------------------------------------------**/
  976.  
  977. pascal OSErr SetWindowProperty(const AEDesc *theWPTokenDesc, const AEDesc *dataDesc)
  978. {
  979.       Str255          name;
  980.     DPtr            theDocument;
  981.     short                 size;
  982.     short                 font;
  983.     OSErr           err;
  984.     OSErr           ignoreErr;
  985.     Rect            thePosnRect;
  986.     Boolean         theBoolean;
  987.     TEHandle        theHTE;
  988.     GrafPtr         oldPort;
  989.     Point           thePosn;
  990.     THPrint         theTHPrint;
  991.     windowPropToken theWindowPropToken;
  992.     AEDesc          newDesc;
  993.     AEDesc          tokenDesc;
  994.     Size            tokenSize;
  995.     TextToken       myTextToken;
  996.     short           hOffset;
  997.     short           vOffset;
  998.  
  999.     if (err = AECoerceDesc(theWPTokenDesc, typeMyWindowProp, &newDesc))
  1000.         return err;
  1001.  
  1002.     GetRawDataFromDescriptor(
  1003.         &newDesc,
  1004.         (Ptr)&theWindowPropToken,
  1005.         sizeof(theWindowPropToken),
  1006.         &tokenSize);
  1007.  
  1008.     err = AEDisposeDesc(&newDesc);
  1009.  
  1010.     GetPort(&oldPort);
  1011.     SetPort(theWindowPropToken.tokenWindowToken);
  1012.  
  1013.     theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1014.  
  1015.     switch (theWindowPropToken.tokenProperty) {
  1016.     case pName:
  1017.         err = GetPStringFromDescriptor(dataDesc, (char *)name);
  1018.         if (err==noErr)
  1019.             if (theDocument->kind != kDocumentWindow)
  1020.                 return errAEEventNotHandled;
  1021.             else if (name[0] == 0)
  1022.                 err = errAEWrongDataType;
  1023.             else {
  1024.                 SetWTitle(theWindowPropToken.tokenWindowToken, name);
  1025.                 PLstrcpy(theDocument->theFileName, name); /* Should we do this??? */
  1026.                 theDocument->dirty = true;
  1027.             }
  1028.         break;
  1029.  
  1030.     case pText:
  1031.     case pContents:
  1032.         theHTE = theDocument->theText;
  1033.         TESetSelect(0, 32000, theHTE);
  1034.  
  1035.         if (theDocument->kind == kDocumentWindow) {
  1036.             DoTEDeleteSectionRecalc(theDocument);
  1037.         } else if (!theDocument->u.cons.selected || (*theHTE)->selStart < theDocument->u.cons.fence) {
  1038.             SysBeep(1);
  1039.             
  1040.             return errAEEventNotHandled;
  1041.         }
  1042.         
  1043.         TEDelete(theHTE);
  1044.         GetTextFromDescIntoTEHandle(dataDesc, theHTE);
  1045.         EnforceMemory(theDocument, theHTE);
  1046.         
  1047.         theDocument->dirty = true;
  1048.         break;
  1049.  
  1050.     case pBounds:
  1051.         err = GetRectFromDescriptor(dataDesc, &thePosnRect);
  1052.         /* the rectangle is for the structure region, and is in global coordinates */
  1053.         /* MoveWindow and SizeWindow apply to the content region, so we have to massage a little */
  1054.  
  1055.         thePosnRect.top    += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.top -
  1056.                                      (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.top;
  1057.  
  1058.         thePosnRect.left   += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.left -
  1059.                                      (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.left;
  1060.  
  1061.         thePosnRect.bottom += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.bottom -
  1062.                                      (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.bottom;
  1063.  
  1064.         thePosnRect.right  += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.right -
  1065.                                      (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.right;
  1066.  
  1067.         if (EmptyRect(&thePosnRect))
  1068.             err = errAECorruptData;
  1069.         else {
  1070.             MoveWindow(
  1071.                 theWindowPropToken.tokenWindowToken,
  1072.                 thePosnRect.left,
  1073.                 thePosnRect.top,
  1074.                 false);
  1075.             SizeWindow(
  1076.                 theWindowPropToken.tokenWindowToken,
  1077.                 thePosnRect.right- thePosnRect.left,
  1078.                 thePosnRect.bottom-thePosnRect.top,
  1079.                 true);
  1080.             ResizeWindow(theDocument);
  1081.         }
  1082.         break;
  1083.  
  1084.     case pPosition:
  1085.         err = GetPointFromDescriptor(dataDesc, &thePosn);
  1086.         /* the point is for the structure region, and is in global coordinates */
  1087.         /* MoveWindow applies to the content region, so we have to massage a little */
  1088.  
  1089.         hOffset = (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.left -
  1090.                      (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.left;
  1091.  
  1092.         vOffset = (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.top -
  1093.                      (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.top;
  1094.  
  1095.         thePosn.v  += vOffset;
  1096.         thePosn.h  += hOffset;
  1097.  
  1098.         MoveWindow(
  1099.             theWindowPropToken.tokenWindowToken,
  1100.             thePosn.h,
  1101.             thePosn.v,
  1102.             false);
  1103.  
  1104.         ResizeWindow(theDocument);
  1105.         break;
  1106.  
  1107.     case pIsZoomed:
  1108.         err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1109.         if (theBoolean)
  1110.             ZoomWindow(qd.thePort, inZoomOut, false);
  1111.         else
  1112.             ZoomWindow(qd.thePort, inZoomIn, false);
  1113.  
  1114.         ResizeWindow(theDocument);
  1115.         break;
  1116.  
  1117.     case pVisible:
  1118.         err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1119.         if (theBoolean)
  1120.             DoShowWindow(theWindowPropToken.tokenWindowToken);
  1121.         else
  1122.             DoHideWindow(theWindowPropToken.tokenWindowToken);
  1123.         break;
  1124.  
  1125.     case pPageSetup:
  1126.         err = GetTHPrintFromDescriptor(dataDesc, &theTHPrint);
  1127.  
  1128.         if (theTHPrint) {
  1129.             if (theDocument->thePrintSetup)
  1130.                 DisposHandle((Handle)theDocument->thePrintSetup);
  1131.  
  1132.             theDocument->thePrintSetup = theTHPrint;
  1133.  
  1134.             ResizePageSetupForDocument(theDocument);
  1135.         }
  1136.         break;
  1137.  
  1138.     case pShowBorders:
  1139.         if (theDocument->kind != kDocumentWindow)
  1140.             return errAEEventNotHandled;
  1141.             
  1142.         err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1143.         theDocument->u.reg.showBorders = theBoolean;
  1144.         if (theBoolean)
  1145.             DrawPageExtras(theDocument); /* Does the clipping as well as drawing borders/page breaks */
  1146.         else
  1147.             InvalidateDocument(theDocument);
  1148.         break;
  1149.  
  1150.     case pFont:
  1151.         err = GetPStringFromDescriptor(dataDesc, (char *)name);
  1152.         GetFNum(name, &font);
  1153.     
  1154.         (*theDocument->theText)->txFont = font;
  1155.         RecalcFontInfo(theDocument->theText);
  1156.         AdjustScrollbars(theDocument, false);
  1157.         DrawPageExtras(theDocument);
  1158.         
  1159.         if (theDocument->kind == kDocumentWindow)
  1160.             theDocument->dirty = true;
  1161.     
  1162.         if (theDocument->theWindow == FrontWindow() && !gInBackground)
  1163.             AdjustScript(theDocument);
  1164.  
  1165.         break;
  1166.  
  1167.     case pPointSize:
  1168.         err = GetIntegerFromDescriptor(dataDesc, &size);
  1169.  
  1170.         (*theDocument->theText)->txSize = size;
  1171.         RecalcFontInfo(theDocument->theText);
  1172.         AdjustScrollbars(theDocument, false);
  1173.         DrawPageExtras(theDocument);
  1174.         
  1175.         if (theDocument->kind == kDocumentWindow)
  1176.             theDocument->dirty = true;
  1177.  
  1178.         if (theDocument->theWindow == FrontWindow() && !gInBackground)
  1179.             AdjustScript(theDocument);
  1180.  
  1181.         break;
  1182.  
  1183.     case pSelection:
  1184.         err = AECoerceDesc(dataDesc, typeMyText, &tokenDesc);
  1185.  
  1186.         GetRawDataFromDescriptor(&tokenDesc,
  1187.                                                          (Ptr)&myTextToken,
  1188.                                                          sizeof(myTextToken),
  1189.                                                          &tokenSize);
  1190.  
  1191.         ignoreErr = AEDisposeDesc(&tokenDesc);
  1192.  
  1193.         if (err == noErr) {
  1194.             /* got a text token */
  1195.  
  1196.             theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  1197.             theHTE      = theDocument->theText;
  1198.  
  1199.             TESetSelect(
  1200.                 myTextToken.tokenOffset-1,
  1201.                 myTextToken.tokenOffset+myTextToken.tokenLength-1,
  1202.                 theHTE);
  1203.         }
  1204.         break;
  1205.  
  1206.     case pIndex:
  1207.     case pIsModal:
  1208.     case pIsResizable:
  1209.     case pHasTitleBar:
  1210.     case pHasCloseBox:
  1211.     case pIsFloating:
  1212.     case pIsZoomable:
  1213.     case pIsModified:
  1214.         err = errAEEventNotHandled; /* We don't allow these to be set */
  1215.         break;
  1216.     }
  1217.     
  1218.     SetPort(oldPort);
  1219.  
  1220.     return err;
  1221. } /* SetWindowProperty */
  1222.  
  1223. /* -----------------------------------------------------------------------
  1224.         Name:         SetTextProperty
  1225.         Purpose:        Sets the text property specfied by theTextPropToken to
  1226.                         that in dataDesc.
  1227.      -----------------------------------------------------------------------**/
  1228.  
  1229. pascal OSErr SetTextProperty(const AEDesc *tokenDesc, const AEDesc *dataDesc)
  1230. {
  1231.     TEHandle      theHTE;
  1232.     DPtr          theDoc;
  1233.     OSErr         myErr;
  1234.     textPropToken theTextPropToken;
  1235.     AEDesc        newDesc;
  1236.     Size          tokenSize;
  1237.  
  1238.     newDesc.dataHandle = nil;
  1239.  
  1240.     if (myErr = AECoerceDesc(tokenDesc, typeMyTextProp, &newDesc))
  1241.         return myErr;
  1242.  
  1243.     GetRawDataFromDescriptor(&newDesc, (Ptr)&theTextPropToken, sizeof(theTextPropToken), &tokenSize);
  1244.     myErr             =    AEDisposeDesc(&newDesc);
  1245.     theDoc             =    DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1246.     
  1247.     if (theDoc->kind == kDocumentWindow)
  1248.         theDoc->dirty     =    true;
  1249.  
  1250.     switch (theTextPropToken.propertyProperty) {
  1251.     case pText:
  1252.     case pContents:
  1253.         theHTE = theDoc->theText;
  1254.         TESetSelect(
  1255.             theTextPropToken.propertyTextToken.tokenOffset-1,
  1256.             theTextPropToken.propertyTextToken.tokenOffset+theTextPropToken.propertyTextToken.tokenLength-1,
  1257.             theHTE);
  1258.         
  1259.         if (theDoc->kind == kDocumentWindow) {
  1260.             DoTEDeleteSectionRecalc(theDoc);
  1261.         } else if (!theDoc->u.cons.selected || (*theHTE)->selStart < theDoc->u.cons.fence) {
  1262.             SysBeep(1);
  1263.             
  1264.             return errAEEventNotHandled;
  1265.         }
  1266.         
  1267.         TEDelete(theHTE);
  1268.         myErr = GetTextFromDescIntoTEHandle(dataDesc, theHTE);
  1269.         EnforceMemory(theDoc, theHTE);
  1270.             
  1271.         theDoc->dirty = true;
  1272.         
  1273.         return myErr;
  1274.     }
  1275.  
  1276.     return errAEWrongDataType;
  1277. } /* SetTextProperty */
  1278.  
  1279. /* -----------------------------------------------------------------------
  1280.         Name:         HandleSetData
  1281.         Purpose:        Resolves the object into a token (could be one of many) and
  1282.                         the sets the data of that object to dataDesc.
  1283.      -----------------------------------------------------------------------**/
  1284.  
  1285. pascal OSErr HandleSetData(const AEDesc *theObj, const AEDesc *dataDesc)
  1286. {
  1287.     OSErr           myErr;
  1288.     AEDesc          newDesc;
  1289.     DPtr            theDocument;
  1290.     TEHandle        theHTE;
  1291.     TextToken       theTextToken;
  1292.     Size            tokenSize;
  1293.     AEDesc          objTokenDesc;
  1294.     OSErr           ignoreErr;
  1295.  
  1296.     objTokenDesc.dataHandle = nil;
  1297.     newDesc.dataHandle      = nil;
  1298.  
  1299.     /*
  1300.         Coerce theObj into a token which we can use -
  1301.              set the property or data for that token
  1302.     */
  1303.  
  1304.     myErr = AEResolve(theObj ,kAEIDoMinimum, &objTokenDesc);
  1305.  
  1306.     /* We don't actually allow ANY app property setting, but
  1307.         just incase we'll decode looking for an typeMyApplProp and flag an error -
  1308.          do same for menu related tokens
  1309.     */
  1310.  
  1311.     if (
  1312.         (objTokenDesc.descriptorType == typeMyApplProp) ||
  1313.         (objTokenDesc.descriptorType == typeMyMenu    ) ||
  1314.         (objTokenDesc.descriptorType == typeMyMenuProp) ||
  1315.         (objTokenDesc.descriptorType == typeMyMenuItem) ||
  1316.         (objTokenDesc.descriptorType == typeMyItemProp)
  1317.     )
  1318.         myErr = errAEWrongDataType;
  1319.     else if (objTokenDesc.descriptorType == typeMyWindowProp)
  1320.         myErr = SetWindowProperty(&objTokenDesc, dataDesc);
  1321.     else if (objTokenDesc.descriptorType == typeMyTextProp)
  1322.         myErr = SetTextProperty(&objTokenDesc, dataDesc);
  1323.     else if (objTokenDesc.descriptorType == typeMyText)
  1324.         if (!AECoerceDesc(&objTokenDesc, typeMyText, &newDesc)) {
  1325.             GetRawDataFromDescriptor(&newDesc, (Ptr)&theTextToken, sizeof(theTextToken), &tokenSize);
  1326.  
  1327.             myErr         = AEDisposeDesc(&newDesc);
  1328.             theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  1329.             theHTE        = theDocument->theText;
  1330.  
  1331.             TESetSelect(
  1332.                 theTextToken.tokenOffset-1,
  1333.                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  1334.                 theHTE);
  1335.                 
  1336.             if (theDocument->kind == kDocumentWindow) {
  1337.                 DoTEDeleteSectionRecalc(theDocument);
  1338.             } else if (!theDocument->u.cons.selected || (*theHTE)->selStart < theDocument->u.cons.fence) {
  1339.                 SysBeep(1);
  1340.                 
  1341.                 return errAEEventNotHandled;
  1342.             }
  1343.             
  1344.             TEDelete(theHTE);
  1345.             myErr = GetTextFromDescIntoTEHandle(dataDesc, theHTE);
  1346.             EnforceMemory(theDocument, theHTE);
  1347.                 
  1348.             theDocument->dirty = true;
  1349.         }
  1350.  
  1351.     ignoreErr = AEDisposeDesc(&objTokenDesc);
  1352.  
  1353.     return myErr;
  1354. }    /* HandleSetData */
  1355.  
  1356. /*
  1357.     A few convenient FORWARDS...
  1358. */
  1359.  
  1360. pascal OSErr MakeWindowObj(WindowPtr theWindow, AEDesc *dMyDoc);
  1361.  
  1362. /*
  1363.     Back to real code
  1364. */
  1365. pascal OSErr MakeSelTextObj(WindowPtr theWindow, TEHandle theTextEditHandle, AEDesc *selTextObj)
  1366. {
  1367.     OSErr    myErr;
  1368.     OSErr    ignoreErr;
  1369.     AEDesc   dNull;
  1370.     AEDesc   dMyDoc;
  1371.     AEDesc   startOfs;
  1372.     AEDesc   endOfs;
  1373.     AEDesc   startObj;
  1374.     AEDesc   endObj;
  1375.     AEDesc   rangeDesc;
  1376.     long     startChar;
  1377.     long     endChar;
  1378.     Boolean  spotFlag;
  1379.  
  1380.     myErr = noErr;
  1381.  
  1382.     if (theWindow==nil)
  1383.         return noErr;
  1384.  
  1385.     selTextObj->dataHandle = nil;
  1386.     dMyDoc.dataHandle      = nil;
  1387.     startObj.dataHandle    = nil;
  1388.     endObj.dataHandle      = nil;
  1389.  
  1390.     /*
  1391.         make the window object
  1392.     */
  1393.  
  1394.     if (myErr = MakeWindowObj(theWindow, &dMyDoc))
  1395.         return myErr;
  1396.  
  1397.     /* get the start and end of selection */
  1398.  
  1399.     startChar = (*theTextEditHandle)->selStart+1;    /* start counting obj's from 1, not 0 */
  1400.     endChar   = (*theTextEditHandle)->selEnd;
  1401.     spotFlag  = ((*theTextEditHandle)->selStart == (*theTextEditHandle)->selEnd);
  1402.  
  1403.     if (myErr = CreateOffsetDescriptor(startChar, &startOfs))
  1404.         return myErr;
  1405.  
  1406.     if (spotFlag)
  1407.         myErr = CreateObjSpecifier(cSpot, &dMyDoc, formAbsolutePosition, &startOfs, true, selTextObj);
  1408.     else {
  1409.         /* not a spot - must represent as range */
  1410.         /* make obj for start char */
  1411.  
  1412.         myErr = AECreateDesc(typeNull, nil , 0, &dNull);
  1413.  
  1414.         myErr = CreateObjSpecifier(cChar, &dMyDoc, formAbsolutePosition, &startOfs, false, &startObj);
  1415.  
  1416.         if (myErr==noErr)
  1417.             myErr = CreateOffsetDescriptor(endChar, &endOfs);
  1418.  
  1419.         if (myErr==noErr)
  1420.             myErr = CreateObjSpecifier(cChar, &dMyDoc, formAbsolutePosition, &endOfs, false, &endObj);
  1421.  
  1422.         if (myErr==noErr)
  1423.             myErr = CreateRangeDescriptor(&startObj, &endObj, false, &rangeDesc);
  1424.  
  1425.         if (myErr==noErr)
  1426.             myErr = CreateObjSpecifier(cText, &dMyDoc, formRange, &rangeDesc, true, selTextObj);
  1427.  
  1428.         if (startObj.dataHandle)
  1429.           ignoreErr = AEDisposeDesc(&startObj);
  1430.  
  1431.         if (startOfs.dataHandle)
  1432.           ignoreErr = AEDisposeDesc(&startOfs);
  1433.  
  1434.         if (endObj.dataHandle)
  1435.           ignoreErr = AEDisposeDesc(&endObj);
  1436.  
  1437.         if (endOfs.dataHandle)
  1438.           ignoreErr = AEDisposeDesc(&endOfs);
  1439.     }
  1440.  
  1441.     return myErr;
  1442. }    /* MakeSelTextObj */
  1443.  
  1444. /* -----------------------------------------------------------------------
  1445.         Name:             DoSetData
  1446.         Purpose:        Handles the SetData Apple Event, extracting the direct
  1447.                                 object (which says what to set) and the data (what to set
  1448.                                 it to).
  1449.      -----------------------------------------------------------------------**/
  1450.  
  1451. pascal OSErr DoSetData(const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefCon)
  1452. {
  1453. #if !defined(powerc) && !defined(__powerc)
  1454. #pragma unused (reply, handlerRefCon)
  1455. #endif
  1456.  
  1457.     OSErr  myErr;
  1458.     OSErr  ignoreErr;
  1459.     AEDesc myDirObj;
  1460.     AEDesc myDataDesc;
  1461.  
  1462.     myDataDesc.dataHandle = nil;
  1463.     myDirObj.dataHandle   = nil;
  1464.  
  1465.     /* pick up the direct object, which is the object whose data is to be set */
  1466.  
  1467.     myErr = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard, &myDirObj);
  1468.  
  1469.     /* now the data to set it to - typeWildCard means get as is*/
  1470.     if (myErr == noErr)
  1471.         myErr = AEGetParamDesc(theAppleEvent, keyAEData, typeWildCard, &myDataDesc);
  1472.  
  1473.     /* missing any parameters? */
  1474.     if (myErr == noErr)
  1475.         myErr = GotRequiredParams(theAppleEvent);
  1476.  
  1477.     /* set the data */
  1478.     if (myErr == noErr)
  1479.         myErr = HandleSetData(&myDirObj, &myDataDesc);
  1480.  
  1481.     if (myDataDesc.dataHandle)
  1482.         ignoreErr = AEDisposeDesc(&myDataDesc);
  1483.  
  1484.     if (myDirObj.dataHandle)
  1485.         ignoreErr = AEDisposeDesc(&myDirObj);
  1486.  
  1487.     return myErr;
  1488. }    /* DoSetData */
  1489.  
  1490. pascal OSErr BuildStyledTextDesc(TEHandle theHTE, short start, short howLong, AEDesc *resultDesc)
  1491. {
  1492.     AEDesc       listDesc;
  1493.     OSErr        myErr;
  1494.     OSErr        ignoreErr;
  1495.  
  1496.     listDesc.dataHandle = nil;
  1497.  
  1498.     TESetSelect(start-1, start+howLong-2, theHTE);
  1499.  
  1500.     myErr = AECreateList(nil, 0, true,  &listDesc);
  1501.  
  1502.     HLock((Handle)(**theHTE).hText);
  1503.  
  1504.     if (myErr==noErr)
  1505.         myErr = AEPutKeyPtr(&listDesc,
  1506.                                   keyAEText,
  1507.                                                 typeChar,
  1508.                                                 (Ptr)&(*(**theHTE).hText)[start-1],
  1509.                                                 howLong);
  1510.  
  1511.     HUnlock((Handle)(**theHTE).hText);
  1512.  
  1513.     myErr = AEPutKeyPtr(&listDesc, keyAEStyles, typeScrapStyles, (Ptr)nil, 0);
  1514.  
  1515.     if (myErr==noErr)
  1516.         myErr = AECoerceDesc(&listDesc, typeStyledText, resultDesc); // should be typeIntlText
  1517.  
  1518.     if (listDesc.dataHandle)
  1519.         ignoreErr = AEDisposeDesc(&listDesc);
  1520.  
  1521.     return myErr;
  1522. }
  1523.  
  1524. /* -----------------------------------------------------------------------
  1525.         Name:             GetTextProperty
  1526.         Purpose:        Fills dataDesc with the requested text property.
  1527.      -----------------------------------------------------------------------**/
  1528.  
  1529. pascal OSErr GetTextProperty(const AEDesc *theTokenDesc, AEDesc *dataDesc)
  1530. {
  1531.       DPtr          theDocument;
  1532.     TEHandle      theHTE;
  1533.     short         theSize;
  1534.     GrafPtr       oldPort;
  1535.     textPropToken theTextPropToken;
  1536.     OSErr         myErr;
  1537.     Size          tokenSize;
  1538.     AEDesc        newDesc;
  1539.  
  1540.       if (myErr = AECoerceDesc(theTokenDesc, typeMyTextProp, &newDesc))
  1541.         return myErr;
  1542.  
  1543.     GetRawDataFromDescriptor(&newDesc, (Ptr)&theTextPropToken, sizeof(theTextPropToken), &tokenSize);
  1544.     myErr= AEDisposeDesc(&newDesc);
  1545.  
  1546.     /*
  1547.         For each property we build a descriptor to be returned as the reply.
  1548.     */
  1549.  
  1550.     theDocument = DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1551.     theHTE         = theDocument->theText;
  1552.  
  1553.     switch (theTextPropToken.propertyProperty) {
  1554.     case pText:
  1555.     case pContents:
  1556.         return BuildStyledTextDesc(
  1557.                         theHTE,
  1558.                         theTextPropToken.propertyTextToken.tokenOffset,
  1559.                         theTextPropToken.propertyTextToken.tokenLength,
  1560.                         dataDesc);
  1561.     case pStringWidth:
  1562.         GetPort(&oldPort);
  1563.         SetPort(theTextPropToken.propertyTextToken.tokenWindow);
  1564.  
  1565.         HLock((Handle)(*theHTE)->hText);
  1566.         theSize =
  1567.             TextWidth(
  1568.                 &(*theHTE)->hText,
  1569.                 theTextPropToken.propertyTextToken.tokenOffset-1,
  1570.                 theTextPropToken.propertyTextToken.tokenLength);
  1571.         HUnlock((Handle)(*theHTE)->hText);
  1572.  
  1573.         SetPort(oldPort);
  1574.         return CreateOffsetDescriptor(theSize, dataDesc);
  1575.     default:
  1576.         return errAEEventNotHandled;
  1577.     }
  1578. } /*GetTextProperty*/
  1579.  
  1580. /* -----------------------------------------------------------------------
  1581.         Name:         GetWindowProperty
  1582.         Purpose:        Fills dataDesc with the requested window property.
  1583.      -----------------------------------------------------------------------**/
  1584. typedef Rect **RectHandle;
  1585.  
  1586. pascal OSErr GetWindowProperty(const AEDesc *theWPTokenObj, AEDesc *dataDesc)
  1587. {
  1588.      OSErr           theErr;
  1589.     Str255          theName;
  1590.     Boolean         theBoolean;
  1591.     Rect            theRect;
  1592.     Point           thePoint;
  1593.     Rect            winRect;
  1594.     Rect            userRect;
  1595.     short           theIndex;
  1596.     DPtr            theDocument;
  1597.     TEHandle        theHTE;
  1598.     windowPropToken theWindowPropToken;
  1599.     AEDesc          newDesc;
  1600.     Size            tokenSize;
  1601.  
  1602.       if (theErr = AECoerceDesc(theWPTokenObj,typeMyWindowProp, &newDesc))
  1603.           return theErr;
  1604.  
  1605.     GetRawDataFromDescriptor(
  1606.         &newDesc,
  1607.         (Ptr)&theWindowPropToken,
  1608.         sizeof(theWindowPropToken),
  1609.         &tokenSize);
  1610.  
  1611.     theErr = AEDisposeDesc(&newDesc);
  1612.  
  1613.     theErr = kAEGenericErr;
  1614.  
  1615.     switch (theWindowPropToken.tokenProperty) {
  1616.     case pName:
  1617.         GetWTitle(theWindowPropToken.tokenWindowToken, theName);
  1618.  
  1619.         theErr = AECreateDesc(typeChar, (Ptr)&theName[1], theName[0], dataDesc);
  1620.         break;
  1621.     case pText:
  1622.     case pContents:
  1623.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1624.         theHTE      = theDocument->theText;
  1625.         theErr         = BuildStyledTextDesc(theHTE, 1, (**theHTE).teLength, dataDesc);
  1626.         break;
  1627.     case pBounds:
  1628.         SetPort(theWindowPropToken.tokenWindowToken);
  1629.  
  1630.         theRect = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox;
  1631.         theErr  = AECreateDesc(typeQDRectangle, (Ptr)&theRect, sizeof(theRect), dataDesc);
  1632.         break;
  1633.     case pPosition:
  1634.         thePoint.v     = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox.top;
  1635.         thePoint.h     = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox.left;
  1636.         theErr       = AECreateDesc(typeQDPoint, (Ptr)&thePoint, sizeof(thePoint), dataDesc);
  1637.         break;
  1638.     case pVisible:
  1639.         theBoolean     = ((WindowPeek)theWindowPropToken.tokenWindowToken)->visible;
  1640.         theErr          = AECreateDesc(typeBoolean, (Ptr)&theBoolean, sizeof(theBoolean), dataDesc);
  1641.         break;
  1642.     case pIsModal:
  1643.         theBoolean     = false;
  1644.         theErr          = AECreateDesc(typeBoolean, (Ptr)&theBoolean, sizeof(theBoolean), dataDesc);
  1645.         break;
  1646.     case pShowBorders:
  1647.         theDocument    = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1648.         theBoolean    = (theDocument->kind == kDocumentWindow) ? theDocument->u.reg.showBorders : false;
  1649.         theErr          = AECreateDesc(typeBoolean, (Ptr)&theBoolean, sizeof(theBoolean), dataDesc);
  1650.         break;
  1651.     case pIsZoomed:
  1652.         if (((WindowPeek)theWindowPropToken.tokenWindowToken)->spareFlag) {
  1653.             SetPort(theWindowPropToken.tokenWindowToken);
  1654.  
  1655.             userRect = **((RectHandle)((WindowPeek)qd.thePort)->dataHandle);
  1656.             winRect  = qd.thePort->portRect;
  1657.             LocalToGlobal((Point *)&winRect.top);
  1658.             LocalToGlobal((Point *)&winRect.bottom);
  1659.  
  1660.             theBoolean = !EqualRect(&userRect, &winRect);
  1661.         } else
  1662.             theBoolean = false;
  1663.  
  1664.         theErr  = AECreateDesc(typeBoolean, (Ptr)&theBoolean, sizeof(theBoolean), dataDesc);
  1665.         break;
  1666.     case pIsResizable:
  1667.     case pHasTitleBar:
  1668.     case pIsZoomable:
  1669.     case pHasCloseBox:
  1670.         theBoolean     = true;
  1671.         theErr          = AECreateDesc(typeBoolean, (Ptr)&theBoolean, sizeof(theBoolean), dataDesc);
  1672.         break;
  1673.     case pIsFloating:
  1674.         theBoolean     = false;
  1675.         theErr          = AECreateDesc(typeBoolean, (Ptr)&theBoolean, sizeof(theBoolean), dataDesc);
  1676.         break;
  1677.     case pIsModified:
  1678.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1679.         theBoolean  = (theDocument->kind == kDocumentWindow) ? theDocument->dirty : true;
  1680.         theErr          = AECreateDesc(typeBoolean, (Ptr)&theBoolean, sizeof(theBoolean), dataDesc);
  1681.     case pIndex:
  1682.         theIndex = 0;
  1683.         if (theWindowPropToken.tokenWindowToken)
  1684.             do
  1685.                 theIndex++;
  1686.             while (theWindowPropToken.tokenWindowToken != GetWindowPtrOfNthWindow(theIndex));
  1687.         theErr  = AECreateDesc(typeShortInteger, (Ptr)theIndex, sizeof(theIndex), dataDesc);
  1688.         break;
  1689.     case pPageSetup:
  1690.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1691.  
  1692.         HLock((Handle)theDocument->thePrintSetup);
  1693.         theErr  = AECreateDesc(typeTPrint, (Ptr)*(theDocument->thePrintSetup), sizeof(TPrint), dataDesc);
  1694.         HUnlock((Handle)theDocument->thePrintSetup);
  1695.         
  1696.         break;
  1697.     case pSelection:
  1698.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1699.         theErr          = MakeSelTextObj(theWindowPropToken.tokenWindowToken, theDocument->theText, dataDesc);
  1700.         break;
  1701.     case pFont:
  1702.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1703.         
  1704.         GetFontName((*theDocument->theText)->txFont, theName);
  1705.  
  1706.         theErr = AECreateDesc(typeChar, (Ptr)&theName[1], theName[0], dataDesc);
  1707.         break; 
  1708.     case pPointSize:
  1709.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1710.         theErr         = CreateOffsetDescriptor((*theDocument->theText)->txSize, dataDesc);
  1711.         break;
  1712.     case pScriptTag:
  1713.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1714.         theErr         = CreateOffsetDescriptor(FontToScript((*theDocument->theText)->txFont), dataDesc);
  1715.         break;
  1716.     }
  1717.  
  1718.     return theErr;
  1719. } /* GetWindowProperty */
  1720.  
  1721. /** -----------------------------------------------------------------------
  1722.         Name:             GetApplicationProperty
  1723.         Purpose:        Fills dataDesc with the requested application property.
  1724.      -----------------------------------------------------------------------**/
  1725.  
  1726. pascal OSErr GetApplicationProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  1727. {
  1728.       OSErr             theErr;
  1729.     Str255            theName;
  1730.     Boolean           isFront;
  1731.     applPropToken     theApplPropToken;
  1732.     AEDesc            newDesc;
  1733.     Size              tokenSize;
  1734.     AEStream            aes;
  1735.     Handle            scrap;
  1736.  
  1737.     if (theErr = AECoerceDesc(theObjToken, typeMyApplProp, &newDesc))
  1738.         return theErr;
  1739.  
  1740.     GetRawDataFromDescriptor(&newDesc, (Ptr)&theApplPropToken, sizeof(theApplPropToken), &tokenSize);
  1741.  
  1742.     theErr = AEDisposeDesc(&newDesc);
  1743.     theErr = kAEGenericErr;
  1744.  
  1745.     switch (theApplPropToken.tokenApplProperty) {
  1746.     case pName:
  1747.         PLstrcpy((StringPtr)theName, (StringPtr) "\pMacPerl");
  1748.         theErr  = AECreateDesc(typeChar, (Ptr)&theName[1], theName[0], dataDesc);
  1749.         break;
  1750.     case pVersion:
  1751.         PLstrcpy((StringPtr)theName, (StringPtr) "\p4.1.0");
  1752.         theErr  = AECreateDesc(typeChar, (Ptr)&theName[1], theName[0], dataDesc);
  1753.         break;
  1754.     case pIsFrontProcess:
  1755.         isFront = !gInBackground;
  1756.         theErr  = AECreateDesc(typeBoolean, (Ptr)&isFront, sizeof(isFront), dataDesc);
  1757.         break;
  1758.     case pClipboard:
  1759.         if (theErr = AEStream_Open(&aes))
  1760.             break;
  1761.         if (theErr = AEStream_OpenList(&aes))
  1762.             goto abortClipboard;
  1763.         TEFromScrap();
  1764.         scrap = TEScrapHandle();
  1765.         HLock(scrap);
  1766.         theErr = AEStream_WriteDesc(&aes, typeChar, *scrap, GetHandleSize(scrap));
  1767.         HLock(scrap);
  1768.         if (theErr || (theErr = AEStream_CloseList(&aes)))
  1769.             goto abortClipboard;
  1770.         theErr = AEStream_Close(&aes, dataDesc);
  1771.         break;
  1772. abortClipboard:
  1773.         AEStream_Close(&aes, nil);
  1774.         break;
  1775.     }
  1776.     
  1777.     return theErr;
  1778. } /* GetApplicationProperty */
  1779.  
  1780. /** -----------------------------------------------------------------------
  1781.         Name:             GetMenuProperty
  1782.         Purpose:        Fills dataDesc with the requested menu property.
  1783.      -----------------------------------------------------------------------**/
  1784.  
  1785. pascal OSErr GetMenuProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  1786. {
  1787.       OSErr         theErr;
  1788.     Str255        theName;
  1789.     MenuPropToken theMenuPropToken;
  1790.     AEDesc        newDesc;
  1791.     Size          tokenSize;
  1792.  
  1793.     if (theErr = AECoerceDesc(theObjToken, typeMyMenuProp, &newDesc))
  1794.         return theErr;
  1795.  
  1796.     GetRawDataFromDescriptor(&newDesc, (Ptr)&theMenuPropToken, sizeof(theMenuPropToken), &tokenSize);
  1797.  
  1798.     theErr = AEDisposeDesc(&newDesc);
  1799.     theErr = kAEGenericErr;
  1800.  
  1801.     if (theMenuPropToken.theMenuProp == pName)  {
  1802.           PLstrcpy(theName, (**theMenuPropToken.theMenuToken.theTokenMenu).menuData);
  1803.         theErr  = AECreateDesc(typeChar, (Ptr)&theName[1], theName[0], dataDesc);
  1804.     }
  1805.  
  1806.     if (theMenuPropToken.theMenuProp == pMenuID) {
  1807.         theErr  =
  1808.             AECreateDesc(
  1809.                 typeShortInteger,
  1810.                 (Ptr)&theMenuPropToken.theMenuToken.theTokenID,
  1811.                 sizeof(theMenuPropToken.theMenuToken.theTokenID),
  1812.                 dataDesc);
  1813.     }
  1814.  
  1815.     return theErr;
  1816. } /* GetMenuProperty */
  1817.  
  1818. /** -----------------------------------------------------------------------
  1819.         Name:         GetMenuItemProperty
  1820.         Purpose:        Fills dataDesc with the requested menu property.
  1821.      -----------------------------------------------------------------------**/
  1822.  
  1823. pascal OSErr GetMenuItemProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  1824. {
  1825.       OSErr             theErr;
  1826.     Str255            theName;
  1827.     MenuItemPropToken theMenuItemPropToken;
  1828.     AEDesc            newDesc;
  1829.     Size              tokenSize;
  1830.  
  1831.     if (theErr = AECoerceDesc(theObjToken, typeMyItemProp, &newDesc))
  1832.         return theErr;
  1833.  
  1834.     GetRawDataFromDescriptor(&newDesc, (Ptr)&theMenuItemPropToken, sizeof(theMenuItemPropToken), &tokenSize);
  1835.  
  1836.     theErr = AEDisposeDesc(&newDesc);
  1837.     theErr = kAEGenericErr;
  1838.  
  1839.     if (theMenuItemPropToken.theItemProp == pName) {
  1840.           GetItem(
  1841.             theMenuItemPropToken.theItemToken.theMenuToken.theTokenMenu,
  1842.             theMenuItemPropToken.theItemToken.theTokenItem,
  1843.             theName);
  1844.         theErr  = AECreateDesc(typeChar, (Ptr)&theName[1], theName[0], dataDesc);
  1845.     }
  1846.  
  1847.     if (theMenuItemPropToken.theItemProp == pItemNumber) {
  1848.         theErr  =
  1849.             AECreateDesc(
  1850.                 typeShortInteger,
  1851.                 (Ptr)&theMenuItemPropToken.theItemToken.theTokenItem,
  1852.                 sizeof(theMenuItemPropToken.theItemToken.theTokenItem),
  1853.                 dataDesc);
  1854.     }
  1855.  
  1856.     return theErr;
  1857. } /* GetMenuItemProperty */
  1858.  
  1859. /** -----------------------------------------------------------------------
  1860.         Name:         HandleGetData
  1861.         Purpose:        Coerces theObj into a token which we understand and
  1862.                         extracts the data requested in the token and puts it
  1863.                         into dataDesc.
  1864.      -----------------------------------------------------------------------**/
  1865.  
  1866. typedef char chars[32001];
  1867. typedef chars **charsHandle;
  1868.  
  1869. pascal OSErr HandleGetData(AEDesc *theObj, DescType whatType, AEDesc *dataDesc)
  1870. {
  1871. #if !defined(powerc) && !defined(__powerc)
  1872. #pragma unused (whatType)
  1873. #endif
  1874.  
  1875.       OSErr           myErr;
  1876.     AEDesc          newDesc;
  1877.     TextToken       theTextToken;
  1878.     Size            tokenSize;
  1879.     DPtr            theDoc;
  1880.     AEDesc          objTokenDesc;
  1881.  
  1882.     myErr = errAEWrongDataType;
  1883.  
  1884.     /*
  1885.         Coerce theObj into a token which we can use -
  1886.              set the property for that token
  1887.     */
  1888.  
  1889.  
  1890.     if (myErr = AEResolve(theObj, kAEIDoMinimum, &objTokenDesc))
  1891.         return myErr;
  1892.  
  1893.     switch (objTokenDesc.descriptorType) {
  1894.     case typeMyApplProp:
  1895.         myErr = GetApplicationProperty(&objTokenDesc, dataDesc);
  1896.         break;
  1897.     case typeMyMenuProp:
  1898.         myErr = GetMenuProperty(&objTokenDesc, dataDesc);
  1899.         break;
  1900.     case typeMyItemProp:
  1901.         myErr = GetMenuItemProperty(&objTokenDesc, dataDesc);
  1902.         break;
  1903.     case typeMyTextProp:
  1904.         myErr = GetTextProperty(&objTokenDesc, dataDesc);
  1905.         break;
  1906.     case typeMyWindowProp:
  1907.         myErr = GetWindowProperty(&objTokenDesc, dataDesc);
  1908.         break;
  1909.     case typeMyText:
  1910.         if (!AECoerceDesc(&objTokenDesc, typeMyText, &newDesc)) {
  1911.             GetRawDataFromDescriptor(
  1912.                 &newDesc,
  1913.                 (Ptr)&theTextToken,
  1914.                 sizeof(theTextToken),
  1915.                 &tokenSize);
  1916.  
  1917.             myErr     = AEDisposeDesc(&newDesc);
  1918.  
  1919.             theDoc    = DPtrFromWindowPtr(theTextToken.tokenWindow);
  1920.  
  1921.             myErr     =
  1922.                 BuildStyledTextDesc(
  1923.                     theDoc->theText,
  1924.                     theTextToken.tokenOffset,
  1925.                     theTextToken.tokenLength,
  1926.                     dataDesc);
  1927.         break;
  1928.         }
  1929.     }
  1930.  
  1931.     return myErr;
  1932. }    /* HandleGetData */
  1933.  
  1934. /** -----------------------------------------------------------------------
  1935.         Name:         DoGetData
  1936.         Purpose:        Handles the GetData AppleEvent.
  1937.      -----------------------------------------------------------------------**/
  1938.  
  1939. pascal OSErr DoGetData(
  1940.     const AppleEvent *theAppleEvent,
  1941.     AppleEvent *reply,
  1942.     long handlerRefCon)
  1943. {
  1944. #if !defined(powerc) && !defined(__powerc)
  1945. #pragma unused (handlerRefCon)
  1946. #endif
  1947.  
  1948.     OSErr    myErr;
  1949.     OSErr    tempErr;
  1950.     AEDesc   myDirObj;
  1951.     AEDesc   myDataDesc;
  1952.     Size     actualSize;
  1953.     DescType returnedType;
  1954.     DescType reqType;
  1955.  
  1956.     myDataDesc.dataHandle = nil;
  1957.     myDirObj.dataHandle   = nil;
  1958.  
  1959.     /*
  1960.         extract the direct object, which is the object whose data is to be returned
  1961.     */
  1962.  
  1963.     myErr  = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard, &myDirObj);
  1964.  
  1965.     /*
  1966.         now the get the type of data wanted - optional
  1967.     */
  1968.  
  1969.     tempErr =
  1970.         AEGetParamPtr(
  1971.             theAppleEvent,
  1972.             keyAERequestedType,
  1973.             typeType,
  1974.             &returnedType,
  1975.             (Ptr)&reqType,
  1976.             sizeof(reqType),
  1977.             &actualSize);
  1978.  
  1979.     if (tempErr!=noErr)
  1980.         reqType = typeChar;
  1981.  
  1982.     if (myErr == noErr)
  1983.         myErr = GotRequiredParams(theAppleEvent);
  1984.  
  1985.     /* get the data */
  1986.     if (myErr == noErr)
  1987.         myErr = HandleGetData(&myDirObj, reqType, &myDataDesc);
  1988.  
  1989.     /* if they wanted a reply, attach it now */
  1990.     if (myErr==noErr)
  1991.         if (reply->descriptorType != typeNull)
  1992.             myErr = AEPutParamDesc(reply, keyDirectObject, &myDataDesc);
  1993.  
  1994.      if (myDataDesc.dataHandle)
  1995.           tempErr = AEDisposeDesc(&myDataDesc);
  1996.  
  1997.      if (myDirObj.dataHandle)
  1998.           tempErr = AEDisposeDesc(&myDirObj);
  1999.  
  2000.     return myErr;
  2001. }    /* DoGetData */
  2002.  
  2003.  
  2004. /** -----------------------------------------------------------------------
  2005.         Name:         DoGetDataSize
  2006.         Purpose:        Handles the GetDataSize AppleEvent.
  2007.      -----------------------------------------------------------------------**/
  2008.  
  2009. pascal OSErr DoGetDataSize(
  2010.     const AppleEvent *theAppleEvent,
  2011.     AppleEvent *reply,
  2012.     long       handlerRefCon)
  2013. {
  2014. #if !defined(powerc) && !defined(__powerc)
  2015. #pragma unused (handlerRefCon)
  2016. #endif
  2017.  
  2018.     OSErr     myErr;
  2019.     OSErr     tempErr;
  2020.     AEDesc    myDirObj;
  2021.     AEDesc    myDataDesc;
  2022.     Size      actualSize;
  2023.     DescType  returnedType;
  2024.     DescType  reqType;
  2025.     long      dataSize;
  2026.  
  2027.     myDataDesc.dataHandle = nil;
  2028.     myDirObj.dataHandle = nil;
  2029.  
  2030.     /* pick up the direct object, which is the object whose data is to be sized */
  2031.  
  2032.     myErr  = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard, &myDirObj);
  2033.  
  2034.     /* now the get the type wanted - optional*/
  2035.  
  2036.     tempErr =
  2037.         AEGetParamPtr(
  2038.             theAppleEvent,
  2039.             keyAERequestedType,
  2040.             typeType,
  2041.             &returnedType,
  2042.             (Ptr)&reqType,
  2043.             sizeof(reqType),
  2044.             &actualSize);
  2045.  
  2046.     if (tempErr!=noErr)
  2047.         reqType = typeChar;
  2048.  
  2049.     if (myErr == noErr)
  2050.         myErr = GotRequiredParams(theAppleEvent);
  2051.  
  2052.     /* get the data */
  2053.     if (myErr == noErr)
  2054.         myErr = HandleGetData(&myDirObj, reqType, &myDataDesc);
  2055.  
  2056.     /* evaluate size of data and discard, create desc for size */
  2057.     if (myErr == noErr)
  2058.         if (myDataDesc.dataHandle) {
  2059.             dataSize = GetHandleSize((Handle)myDataDesc.dataHandle);
  2060.             DisposHandle((Handle)myDataDesc.dataHandle);
  2061.             myErr  = AECreateDesc(typeLongInteger, (Ptr)&dataSize, sizeof(dataSize), &myDataDesc);
  2062.         }
  2063.  
  2064.  
  2065.     /* if they wanted a reply, attach it now */
  2066.  
  2067.     if (myErr==noErr)
  2068.         if (reply->descriptorType != typeNull)
  2069.             myErr = AEPutParamDesc(reply, keyDirectObject, &myDataDesc);
  2070.  
  2071.     /* discard our copy */
  2072.  
  2073.     if (myDataDesc.dataHandle)
  2074.         tempErr = AEDisposeDesc(&myDataDesc);
  2075.  
  2076.     if (myDirObj.dataHandle)
  2077.         tempErr = AEDisposeDesc(&myDirObj);
  2078.  
  2079.     return myErr;
  2080. }    /* DoGetDataSize */
  2081.  
  2082. /** -----------------------------------------------------------------------
  2083.         Name:         DoNewElement
  2084.         Purpose:        Handles the NewElement AppleEvent. Only Creates windows for
  2085.                     now.
  2086.      -----------------------------------------------------------------------**/
  2087.  
  2088. pascal OSErr DoNewElement(
  2089.     const AppleEvent *theAppleEvent,
  2090.     AppleEvent *reply,
  2091.     long       handlerRefCon)
  2092. {
  2093. #if !defined(powerc) && !defined(__powerc)
  2094. #pragma unused (handlerRefCon)
  2095. #endif
  2096.  
  2097.     OSErr       myErr;
  2098.     OSErr       ignoreErr;
  2099.     DescType      returnedType;
  2100.     DescType      newElemClass;
  2101.     Size        actSize;
  2102.     AEDesc        wndwObjSpec;
  2103.     DPtr        theDoc;
  2104.  
  2105.     wndwObjSpec.dataHandle = nil;
  2106.  
  2107.     myErr =
  2108.         AEGetParamPtr(
  2109.             theAppleEvent,
  2110.             keyAEObjectClass,
  2111.             typeType,
  2112.             &returnedType,
  2113.             (Ptr)&newElemClass,
  2114.             sizeof(newElemClass),
  2115.             &actSize);
  2116.  
  2117.   /* check for missing required parameters */
  2118.  
  2119.   if (myErr == noErr)
  2120.         myErr = GotRequiredParams(theAppleEvent);
  2121.  
  2122.   /* got all required params */
  2123.  
  2124.   /* let's make sure container is the null desc */
  2125.   /* and they want a window */
  2126.  
  2127.   if (newElemClass != cWindow && newElemClass != cDocument)
  2128.     myErr = errAEWrongDataType;
  2129.  
  2130.   /* let's create a new window */
  2131.  
  2132.     if (myErr == noErr)
  2133.         theDoc = NewDocument(false, kDocumentWindow);
  2134.  
  2135.     if (myErr==noErr)
  2136.         if (theDoc == nil)
  2137.             myErr = -1700;
  2138.         else {
  2139.             DoShowWindow(theDoc->theWindow);
  2140.             theDoc->dirty = false;
  2141.             myErr = AEBuild(
  2142.                         &wndwObjSpec, 
  2143.                         "obj{want: type(@), form: 'indx', seld: 1, from: ()}",
  2144.                         sizeof(newElemClass), &newElemClass);
  2145.         }
  2146.  
  2147.     if (myErr == noErr)
  2148.         if (reply->descriptorType != typeNull)
  2149.              myErr = AEPutParamDesc(reply, keyDirectObject, &wndwObjSpec);
  2150.  
  2151.     if (wndwObjSpec.dataHandle)
  2152.         ignoreErr = AEDisposeDesc(&wndwObjSpec);
  2153.  
  2154.       return myErr;
  2155. }    /* DoNewElement */
  2156.  
  2157. /** -----------------------------------------------------------------------
  2158.         Name:         DoIsThereA
  2159.         Purpose:        Handles the IsThereA AppleEvent.
  2160.      -----------------------------------------------------------------------**/
  2161.  
  2162. pascal OSErr DoIsThereA(
  2163.     const AppleEvent *theAppleEvent,
  2164.     AppleEvent       *reply,
  2165.     long             handlerRefCon)
  2166. /*
  2167.     Support check of Windows at first
  2168.  
  2169.     What we do :
  2170.         Get Direct Object
  2171.         Check have all required params
  2172.         Coerce into things we support
  2173.         if we get something back
  2174.             check to see it exists and set reply
  2175.         clean up
  2176.         return
  2177. */
  2178. {
  2179. #if !defined(powerc) && !defined(__powerc)
  2180. #pragma unused (handlerRefCon)
  2181. #endif
  2182.  
  2183.     OSErr         myErr;
  2184.     OSErr         ignoreErr;
  2185.     AEDesc        myDirObject;
  2186.     AEDesc        windDesc;
  2187.     AEDesc        dataDesc;
  2188.     WindowToken   theWindowToken;
  2189.     Size          tokenSize;
  2190.     Boolean       exists;
  2191.  
  2192.     myDirObject.dataHandle = nil;
  2193.     windDesc.dataHandle    = nil;
  2194.     dataDesc.dataHandle    = nil;
  2195.  
  2196.     myErr = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard, &myDirObject);
  2197.  
  2198.     /* check for missing required parameters */
  2199.  
  2200.     if (myErr == noErr)
  2201.         myErr = GotRequiredParams(theAppleEvent);
  2202.  
  2203.     /* got all required params */
  2204.  
  2205.     /* let's make sure they want to check for a window */
  2206.  
  2207.     exists = false;
  2208.  
  2209.     if (myErr == noErr)
  2210.         if (AECoerceDesc(&myDirObject, typeMyWndw, &windDesc)==noErr)
  2211.             if (windDesc.descriptorType!=typeNull) {
  2212.                 GetRawDataFromDescriptor(
  2213.                     &windDesc,
  2214.                     (Ptr)&theWindowToken,
  2215.                     sizeof(theWindowToken),
  2216.                     &tokenSize);
  2217.  
  2218.                 exists = (theWindowToken != nil);
  2219.             }
  2220.  
  2221.     if (myErr == noErr)
  2222.         myErr = AECreateDesc(typeBoolean, (Ptr)&exists, sizeof(exists), &dataDesc);
  2223.  
  2224.     /*
  2225.         if they wanted a reply, which they surely must,
  2226.         attach the result to it╔
  2227.     */
  2228.  
  2229.     if (myErr == noErr)
  2230.         if (reply->descriptorType != typeNull)
  2231.              myErr = AEPutParamDesc(reply, keyDirectObject, &dataDesc);
  2232.  
  2233.     if (dataDesc.dataHandle)
  2234.         ignoreErr = AEDisposeDesc(&dataDesc);
  2235.  
  2236.     if (myDirObject.dataHandle)
  2237.         ignoreErr = AEDisposeDesc(&myDirObject);
  2238.  
  2239.     if (windDesc.dataHandle)
  2240.         ignoreErr = AEDisposeDesc(&windDesc);
  2241.  
  2242.     return myErr;
  2243. }    /* DoIsThereA */
  2244.  
  2245. /** -----------------------------------------------------------------------
  2246.         Name:         DoCloseWindow
  2247.         Purpose:        Handles the Close AppleEvent.
  2248.      -----------------------------------------------------------------------**/
  2249.  
  2250. pascal OSErr DoCloseWindow(
  2251.     const AppleEvent *theAppleEvent,
  2252.     AppleEvent       *reply,
  2253.     long             handlerRefCon)
  2254. {
  2255. #if !defined(powerc) && !defined(__powerc)
  2256. #pragma unused (reply, handlerRefCon)
  2257. #endif
  2258.  
  2259.     OSErr         myErr;
  2260.     OSErr         tempErr;
  2261.     AEDesc        myDirObj;
  2262.     AEDesc        newDesc;
  2263.     WindowToken   theWindowToken;
  2264.     Size          tokenSize;
  2265.     DescType      saveOpt;
  2266.     Size          actSize;
  2267.     DescType      returnedType;
  2268.     DPtr          myDPtr;
  2269.  
  2270.     myDirObj.dataHandle = nil;
  2271.  
  2272.     /* pick up the direct object, which is the object (window) to close */
  2273.  
  2274.     myErr = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard, &myDirObj);
  2275.  
  2276.     /* pick up optional save param, if any */
  2277.  
  2278.     saveOpt = kAEAsk; /* the default */
  2279.  
  2280.     tempErr =
  2281.         AEGetParamPtr(
  2282.             theAppleEvent,
  2283.             keyAESaveOptions,
  2284.             typeEnumerated,
  2285.             &returnedType,
  2286.             (Ptr)&saveOpt,
  2287.             sizeof(saveOpt),
  2288.             &actSize);
  2289.  
  2290.     if (myErr == noErr)
  2291.         myErr = GotRequiredParams(theAppleEvent);
  2292.  
  2293.     /* get the window to close as a window ptr */
  2294.     if (myErr == noErr)
  2295.         if (!AECoerceDesc(&myDirObj, typeMyWndw, &newDesc))
  2296.             if (newDesc.descriptorType!=typeNull)  {
  2297.                 GetRawDataFromDescriptor(
  2298.                     &newDesc,
  2299.                     (Ptr)&theWindowToken,
  2300.                     sizeof(theWindowToken),
  2301.                     &tokenSize);
  2302.  
  2303.                 myErr = AEDisposeDesc(&newDesc);
  2304.  
  2305.                 if (theWindowToken) {
  2306.                     myErr=AESetInteractionAllowed(kAEInteractWithAll); /* Should do this in prefs */
  2307.  
  2308.                     /*
  2309.                         We do some of the close checks here to avoid
  2310.                         calling AEInteractWithUser
  2311.                     */
  2312.                     if (!(myDPtr = DPtrFromWindowPtr(theWindowToken)))
  2313.                         myErr =  errAEIllegalIndex;
  2314.                     else if (myDPtr->kind == kDocumentWindow && (myDPtr->dirty || !myDPtr->u.reg.everSaved))
  2315.                         if (saveOpt != kAENo) /* Don't flip layers if force no ask */
  2316.                             myErr = AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  2317.  
  2318.                     if (myErr==noErr)
  2319.                         myErr = DoClose(theWindowToken, true, saveOpt);
  2320.                 } else
  2321.                     myErr =  errAEIllegalIndex;
  2322.             }
  2323.  
  2324.     if (myDirObj.dataHandle)
  2325.         tempErr = AEDisposeDesc(&myDirObj);
  2326.  
  2327.     return myErr;
  2328. }    /* DoCloseWindow */
  2329.  
  2330. /** -----------------------------------------------------------------------
  2331.         Name:             DoSaveWindow
  2332.         Purpose:        Handles the Save AppleEvent.
  2333.      -----------------------------------------------------------------------**/
  2334.  
  2335. pascal OSErr DoSaveWindow(
  2336.     const AppleEvent *theAppleEvent,
  2337.     AppleEvent       *reply,
  2338.     long             handlerRefCon)
  2339. {
  2340. #if !defined(powerc) && !defined(__powerc)
  2341. #pragma unused (reply, handlerRefCon)
  2342. #endif
  2343.  
  2344.     OSErr             myErr;
  2345.     OSErr             tempErr;
  2346.     AEDesc            myDirObj;
  2347.     AEDesc            newDesc;
  2348.     WindowToken       theWindowToken;
  2349.     Size              tokenSize;
  2350.     Size              actSize;
  2351.     DescType          returnedType;
  2352.     DPtr              theDoc;
  2353.     OSType            type;
  2354.     FSSpec            destFSSpec;
  2355.  
  2356.     myDirObj.dataHandle = nil;
  2357.  
  2358.     /* pick up the direct object, which is the window to save */
  2359.  
  2360.     myErr = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard,  &myDirObj);
  2361.  
  2362.     /* pick up optional destination param, if any */
  2363.  
  2364.     tempErr =
  2365.         AEGetParamPtr(
  2366.             theAppleEvent,
  2367.             keyAEDestination,
  2368.               typeFSS,
  2369.             &returnedType,
  2370.             (Ptr)&destFSSpec,
  2371.             sizeof(destFSSpec),
  2372.             &actSize);
  2373.  
  2374.     if (AEGetParamPtr(
  2375.             theAppleEvent,
  2376.             keyAEFileType,
  2377.               typeEnumerated,
  2378.             &returnedType,
  2379.             (Ptr)&type,
  2380.             sizeof(type),
  2381.             &actSize)
  2382.         || !CanSaveAs(type)
  2383.     )
  2384.         type = 0;
  2385.     
  2386.     if (myErr == noErr)
  2387.         myErr = GotRequiredParams(theAppleEvent);
  2388.  
  2389.     /* get the data */
  2390.  
  2391.     if (myErr = AECoerceDesc(&myDirObj, typeMyWndw, &newDesc))    {
  2392.         /* No window, maybe a file? */
  2393.         if (AECoerceDesc(&myDirObj, typeFSS, &newDesc)) {
  2394.             /* Apparently not, maybe just some text ? */
  2395.             if (!AECoerceDesc(&myDirObj, typeChar, &newDesc))
  2396.                 myErr = Handle2File(newDesc.dataHandle, destFSSpec, type ? type : 'TEXT');
  2397.         } else {
  2398.             FSSpec    fromFile;
  2399.             DocType    oldType;
  2400.             
  2401.             GetRawDataFromDescriptor(
  2402.                 &newDesc,
  2403.                 (Ptr)&fromFile,
  2404.                 sizeof(fromFile),
  2405.                 &tokenSize);
  2406.                 
  2407.             oldType = GetDocType(&fromFile);
  2408.             
  2409.             if (oldType == kUnknownDoc)
  2410.                 myErr = errAEWrongDataType;
  2411.             else
  2412.                 myErr = File2File(fromFile, oldType, destFSSpec, type ? type : oldType);
  2413.         }
  2414.     } else if (newDesc.descriptorType!=typeNull) {
  2415.         GetRawDataFromDescriptor(
  2416.             &newDesc,
  2417.             (Ptr)&theWindowToken,
  2418.             sizeof(theWindowToken),
  2419.             &tokenSize);
  2420.  
  2421.         myErr = AEDisposeDesc(&newDesc);
  2422.  
  2423.         if (theWindowToken) {
  2424.             theDoc = DPtrFromWindowPtr(theWindowToken);
  2425.  
  2426.             if (theDoc->kind != kDocumentWindow || theDoc->u.reg.everSaved == false)
  2427.                 if (tempErr != noErr)
  2428.                      /* We had no supplied destination and no default either */
  2429.                     myErr = kAEGenericErr;
  2430.  
  2431.             if (type)
  2432.                 theDoc->type = type;
  2433.                 
  2434.             if (myErr==noErr)
  2435.                 if (tempErr==noErr) { /* we were told where */
  2436.                     myErr = SaveWithoutTemp(theDoc, destFSSpec);
  2437.  
  2438.                     if (myErr==noErr)
  2439.                         AssocAllSections(theDoc);
  2440.                 } else
  2441.                     myErr = SaveUsingTemp(theDoc);
  2442.         } else
  2443.             myErr =  errAEIllegalIndex;
  2444.     }
  2445.  
  2446.     if (myDirObj.dataHandle)
  2447.         tempErr = AEDisposeDesc(&myDirObj);
  2448.  
  2449.     return myErr;
  2450. }    /* DoSaveWindow */
  2451.  
  2452. /** -----------------------------------------------------------------------
  2453.         Name:         DoRevertWindow
  2454.         Purpose:        Handles the Revert AppleEvent.
  2455.      -----------------------------------------------------------------------**/
  2456.  
  2457. pascal OSErr DoRevertWindow(
  2458.     const AppleEvent *theAppleEvent,
  2459.     AppleEvent       *reply,
  2460.     long             handlerRefCon)
  2461. {
  2462. #if !defined(powerc) && !defined(__powerc)
  2463. #pragma unused (reply, handlerRefCon)
  2464. #endif
  2465.  
  2466.     OSErr          myErr;
  2467.     OSErr          ignoreErr;
  2468.     AEDesc         myDirObj;
  2469.     AEDesc         newDesc;
  2470.     WindowToken    theWindowToken;
  2471.     Size           tokenSize;
  2472.     DPtr           theDoc;
  2473.  
  2474.     myDirObj.dataHandle = nil;
  2475.  
  2476.   /* pick up the direct object, which is the window to revert */
  2477.  
  2478.       if (myErr = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard, &myDirObj))
  2479.           return myErr;
  2480.  
  2481.       GotRequiredParams(theAppleEvent);
  2482.  
  2483.   /* get the window to revert from the direct object */
  2484.  
  2485.     myErr = AECoerceDesc(&myDirObj, typeMyWndw, &newDesc);
  2486.  
  2487.       if (myErr == noErr)
  2488.         if (newDesc.descriptorType!=typeNull) {
  2489.             GetRawDataFromDescriptor(
  2490.                 &newDesc,
  2491.                 (Ptr)&theWindowToken,
  2492.                 sizeof(theWindowToken),
  2493.                 &tokenSize);
  2494.  
  2495.             myErr = AEDisposeDesc(&newDesc);
  2496.  
  2497.             if (theWindowToken) {
  2498.                 theDoc = DPtrFromWindowPtr(theWindowToken);
  2499.  
  2500.                 if (theDoc->kind != kDocumentWindow)
  2501.                     myErr = errAEEventNotHandled;
  2502.                 else {
  2503.                     HidePen();
  2504.                     TESetSelect(0, (*(theDoc->theText))->teLength, theDoc->theText);
  2505.                     ShowPen();
  2506.                     TEDelete(theDoc->theText);
  2507.     
  2508.                     if (theDoc->u.reg.everSaved) {
  2509.                         myErr = GetFileContents(theDoc->theFSSpec, theDoc);
  2510.                         if (myErr == noErr) {
  2511.                             ResizeWindow(theDoc);
  2512.                             theDoc->dirty = false;
  2513.                         }
  2514.                     }
  2515.     
  2516.                     DoShowWindow(theDoc->theWindow); /* <<< Visible already??? */
  2517.                     DoUpdate(theDoc, theDoc->theWindow);
  2518.                 }
  2519.             } else
  2520.                 myErr =  errAEIllegalIndex;
  2521.         }
  2522.  
  2523.     if (myDirObj.dataHandle)
  2524.         ignoreErr = AEDisposeDesc(&myDirObj);
  2525.  
  2526.   return myErr;
  2527. }    /* DoRevertWindow */
  2528.  
  2529. #endif
  2530.  
  2531. /**-----------------------------------------------------------------------
  2532.         Name:         DoPrintDocuments
  2533.         Purpose:        Print a list of documents (or windows).
  2534. -----------------------------------------------------------------------**/
  2535. pascal OSErr DoPrintDocuments(
  2536.     const AppleEvent *message,
  2537.    AppleEvent       *reply,
  2538.     long refcon)
  2539. {
  2540. #if !defined(powerc) && !defined(__powerc)
  2541. #pragma unused (reply, refcon)
  2542. #endif
  2543.     long          index;
  2544.     long          itemsInList;
  2545.     AEKeyword     keywd;
  2546.     OSErr         err;
  2547.     AEDescList    docList;
  2548.     Size          actSize;
  2549.     DescType      typeCode;
  2550.     FSSpec        theFSSpec;
  2551.     WindowToken   theWindowToken;
  2552.     OSErr         forgetErr;
  2553.     Boolean       talkToUser;
  2554.  
  2555.     err = AEGetParamDesc(message, keyDirectObject, typeAEList, &docList);
  2556.     err = AECountItems(&docList, &itemsInList);
  2557.  
  2558.     for (index = 1; index<=itemsInList; index++)
  2559.         if (err == noErr) {
  2560.             forgetErr =
  2561.                 AEGetNthPtr(
  2562.                     &docList,
  2563.                     index,
  2564.                     typeFSS,
  2565.                     &keywd,
  2566.                     &typeCode,
  2567.                     (Ptr)&theFSSpec,
  2568.                     sizeof(theFSSpec),
  2569.                     &actSize);
  2570.  
  2571.             if (forgetErr == noErr) {
  2572.                 if (err == noErr)
  2573.                     err = IssueAEOpenDoc(theFSSpec);
  2574.  
  2575.                 if (err == noErr)
  2576.                     IssuePrintWindow(FrontWindow());
  2577.  
  2578.                 if (err == noErr)
  2579.                     IssueCloseCommand(FrontWindow());
  2580.             } else { /* wasn't a file - was it a window ? */
  2581.                 err =
  2582.                     AEGetNthPtr(
  2583.                         &docList,
  2584.                         index,
  2585.                         typeMyWndw,
  2586.                         &keywd,
  2587.                         &typeCode,
  2588.                         (Ptr)&theWindowToken,
  2589.                         sizeof(WindowToken),
  2590.                         &actSize);
  2591.  
  2592.                 talkToUser = (AEInteractWithUser(kAEDefaultTimeout, nil, nil) == noErr);
  2593.  
  2594.                 if (err == noErr)
  2595.                     PrintWindow(DPtrFromWindowPtr(theWindowToken), talkToUser);
  2596.             }
  2597.         }
  2598.  
  2599.     if (docList.dataHandle)
  2600.         forgetErr = AEDisposeDesc(&docList);
  2601.  
  2602.     return err;
  2603. } /* DoPrintDocuments */
  2604.  
  2605. #ifndef RUNTIME
  2606.  
  2607. /**-----------------------------------------------------------------------
  2608.         Name:         HandleCreatePub
  2609.         Purpose:        Create a publisher.
  2610. -----------------------------------------------------------------------**/
  2611. pascal OSErr HandleCreatePub(
  2612.     const AppleEvent *theAppleEvent,
  2613.    AppleEvent       *reply,
  2614.     long refcon)
  2615. {
  2616. #if !defined(powerc) && !defined(__powerc)
  2617. #pragma unused (reply, refcon)
  2618. #endif
  2619.  
  2620.     OSErr       myErr;
  2621.     FSSpec      theFSSpec;
  2622.     OSErr       forgetErr;
  2623.     OSErr       forget2Err;
  2624.     AEDesc      myDirObj;
  2625.     AEDesc      myFileLoc;
  2626.     TextToken   theTextToken;
  2627.     DPtr        theDoc;
  2628.     AEDesc      newDesc;
  2629.     long        tokenSize;
  2630.     Boolean     haveFSSpec;
  2631.  
  2632.     myErr = noErr;
  2633.  
  2634.     forgetErr  = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard, &myDirObj);
  2635.     forget2Err = AEGetParamDesc(theAppleEvent, keyAEEditionFileLoc, typeWildCard, &myFileLoc);
  2636.  
  2637.     if (myErr==noErr)
  2638.         myErr = GotRequiredParams(theAppleEvent);
  2639.  
  2640.     if (forgetErr==noErr) { /* Set the selection to the supplied object - if any */
  2641.         forgetErr = AECoerceDesc(&myDirObj, typeMyText, &newDesc);
  2642.         if (newDesc.descriptorType!=typeNull) {
  2643.             GetRawDataFromDescriptor(&newDesc,
  2644.                                                              (Ptr)&theTextToken,
  2645.                                                              sizeof(theTextToken),
  2646.                                                              &tokenSize);
  2647.  
  2648.             theDoc = DPtrFromWindowPtr(theTextToken.tokenWindow);
  2649.  
  2650.             TESetSelect(theTextToken.tokenOffset-1,
  2651.                                     theTextToken.tokenOffset+
  2652.                                                         theTextToken.tokenLength-1,
  2653.                                     theDoc->theText);
  2654.  
  2655.             forgetErr = AEDisposeDesc(&newDesc);
  2656.         }
  2657.     } else
  2658.         theDoc = DPtrFromWindowPtr(FrontWindow());
  2659.  
  2660.     if (theDoc==nil) {
  2661.         /* Should clean up and exit with error */
  2662.     }
  2663.  
  2664.     haveFSSpec = false;
  2665.  
  2666.     if (forget2Err==noErr) { /* Get the Edition Container File */
  2667.         forget2Err = AECoerceDesc(&myDirObj,typeFSS,&newDesc);
  2668.         if (newDesc.descriptorType!=typeNull) {
  2669.             GetRawDataFromDescriptor(&newDesc, (Ptr)&theFSSpec, sizeof(theFSSpec), &tokenSize);
  2670.             forget2Err = AEDisposeDesc(&newDesc);
  2671.             haveFSSpec = true;
  2672.         }
  2673.     }
  2674.  
  2675.     if (haveFSSpec==false)
  2676.         myErr = GetEditionContainer(theDoc, &theFSSpec);
  2677.  
  2678.     if (myErr == noErr)
  2679.         myErr = PublishText(theDoc, &theFSSpec);
  2680.  
  2681.     if (myDirObj.dataHandle)
  2682.         forgetErr = AEDisposeDesc(&myDirObj);
  2683.  
  2684.     if (myFileLoc.dataHandle)
  2685.         forgetErr = AEDisposeDesc(&myFileLoc);
  2686.  
  2687.     return myErr;
  2688. } /* HandleCreatePub */
  2689.  
  2690.  
  2691. pascal OSErr MyCountProc(
  2692.     DescType desiredType,
  2693.     DescType containerClass,
  2694.     const AEDesc *container,
  2695.     long *result);
  2696.  
  2697. /** -----------------------------------------------------------------------
  2698.         Name:       HandleNumberOfElements
  2699.         Purpose:        Handles the Number Of Elements AppleEvent.
  2700.      -----------------------------------------------------------------------**/
  2701.  
  2702. pascal OSErr HandleNumberOfElements(
  2703.     const AppleEvent *theAppleEvent,
  2704.     AppleEvent *reply,
  2705.     long       handlerRefCon)
  2706. {
  2707. #if !defined(powerc) && !defined(__powerc)
  2708. #pragma unused (handlerRefCon)
  2709. #endif
  2710.  
  2711.       OSErr    myErr;
  2712.       OSErr    forgetErr;
  2713.     AEDesc   myDirObj;
  2714.     DescType myClass;
  2715.     long     myCount;
  2716.     DescType returnedType;
  2717.     Size     actSize;
  2718.  
  2719.     myErr                        = errAEEventNotHandled;
  2720.     myDirObj.dataHandle     = nil;
  2721.  
  2722.     /* pick up direct object, which is the container in which things are to be counted */
  2723.  
  2724.     myErr = AEGetParamDesc(theAppleEvent, keyDirectObject, typeWildCard, &myDirObj);
  2725.  
  2726.     /* now the class of objects to be counted */
  2727.  
  2728.     myErr =
  2729.         AEGetParamPtr(
  2730.             theAppleEvent,
  2731.             keyAEObjectClass,
  2732.             typeType,
  2733.             &returnedType,
  2734.             (Ptr)&myClass,
  2735.             sizeof(myClass),
  2736.             &actSize);
  2737.  
  2738.     /* missing any parameters? */
  2739.  
  2740.     myErr = GotRequiredParams(theAppleEvent);
  2741.  
  2742.     /* now count */
  2743.  
  2744.     if (myErr == noErr)
  2745.         myErr = MyCountProc(myClass,myDirObj.descriptorType, &myDirObj,&myCount);
  2746.  
  2747.     /* add result to reply */
  2748.  
  2749.     if (myErr == noErr)
  2750.         if (reply->descriptorType != typeNull)
  2751.              myErr  =
  2752.                  AEPutParamPtr(
  2753.                     reply,
  2754.                     keyDirectObject,
  2755.                     typeLongInteger,
  2756.                     (Ptr)&myCount,
  2757.                     sizeof(myCount));
  2758.     if (myErr == noErr)
  2759.         forgetErr  = AEDisposeDesc(&myDirObj);
  2760.  
  2761.     return myErr;
  2762. }    /* HandleNumberOfElements */
  2763.  
  2764. /** -----------------------------------------------------------------------
  2765.         Name:             HandleShowSelection
  2766.         Purpose:        Handles the Make Selection Visible AppleEvent.
  2767.      -----------------------------------------------------------------------**/
  2768.  
  2769. pascal OSErr HandleShowSelection(
  2770.     const AppleEvent *theAppleEvent,
  2771.     AppleEvent       *reply,
  2772.     long             handlerRefCon)
  2773. {
  2774. #if !defined(powerc) && !defined(__powerc)
  2775. #pragma unused (reply,handlerRefCon)
  2776. #endif
  2777.  
  2778.     OSErr       myErr;
  2779.     OSErr       ignoreErr;
  2780.     AEDesc      myDirObj;
  2781.     AEDesc      newDesc;
  2782.     AEDesc      tokenDesc;
  2783.     Size        actSize;
  2784.     WindowToken theWindowToken;
  2785.     DPtr        theDocument;
  2786.     TEHandle    theHTE;
  2787.  
  2788.     myErr      = errAEEventNotHandled;
  2789.     myDirObj.dataHandle  = nil;
  2790.     tokenDesc.dataHandle = nil;
  2791.  
  2792.     /*
  2793.         pick up direct object, i.e. the window in which to show the selection
  2794.     */
  2795.  
  2796.     myErr  =
  2797.         AEGetParamDesc(
  2798.             theAppleEvent,
  2799.             keyDirectObject,
  2800.             typeWildCard,
  2801.             &myDirObj);
  2802.  
  2803.     /*
  2804.         missing any parameters?
  2805.     */
  2806.  
  2807.     myErr = GotRequiredParams(theAppleEvent);
  2808.  
  2809.     /*
  2810.         convert object to WindowToken which we understand
  2811.     */
  2812.     myErr = AEResolve(&myDirObj, kAEIDoMinimum, &tokenDesc);
  2813.  
  2814.     if (myErr == noErr)
  2815.         if (tokenDesc.descriptorType==typeMyWndw) {
  2816.             if (AECoerceDesc(&myDirObj, typeMyWndw, &newDesc) == noErr) {
  2817.                 GetRawDataFromDescriptor(
  2818.                     &newDesc,
  2819.                     (Ptr)&theWindowToken,
  2820.                     sizeof(theWindowToken),
  2821.                     &actSize);
  2822.  
  2823.                 ignoreErr = AEDisposeDesc(&newDesc);
  2824.  
  2825.                 if (myErr==noErr)
  2826.                     if (theWindowToken)
  2827.                         ShowSelect(DPtrFromWindowPtr(theWindowToken));
  2828.                     else
  2829.                         myErr = errAEIllegalIndex;
  2830.             }
  2831.         } else if (tokenDesc.descriptorType==typeMyText) {
  2832.             myErr =
  2833.                 SetSelectionOfAppleEventObject(
  2834.                     keyDirectObject,
  2835.                     theAppleEvent,
  2836.                     &theDocument,
  2837.                     &theHTE);
  2838.  
  2839.             if (theDocument)
  2840.               ShowSelect(theDocument);
  2841.             else
  2842.                 myErr = errAEIllegalIndex;
  2843.         } else
  2844.             myErr = errAEEventNotHandled;
  2845.  
  2846.     if (myDirObj.dataHandle)
  2847.         ignoreErr = AEDisposeDesc(&myDirObj);
  2848.  
  2849.     if (tokenDesc.dataHandle)
  2850.         ignoreErr = AEDisposeDesc(&tokenDesc);
  2851.  
  2852.     return myErr;
  2853. }    /* HandleShowSelection */
  2854.  
  2855. /** -----------------------------------------------------------------------
  2856.         Name:         HandleSelect
  2857.         Purpose:        Handles the Select AppleEvent.
  2858.      -----------------------------------------------------------------------**/
  2859.  
  2860. pascal OSErr HandleSelect(
  2861.     const AppleEvent *theAppleEvent,
  2862.     AppleEvent       *reply,
  2863.     long             handlerRefCon)
  2864. {
  2865. #if !defined(powerc) && !defined(__powerc)
  2866. #pragma unused (reply,handlerRefCon)
  2867. #endif
  2868.  
  2869.     OSErr       myErr;
  2870.     OSErr       ignoreErr;
  2871.     AEDesc      myDirObj;
  2872.     AEDesc      tokenDesc;
  2873.     DPtr        theDocument;
  2874.     Size        actSize;
  2875.     TEHandle    theHTE;
  2876.     WindowToken theWindowToken;
  2877.  
  2878.     myErr      = errAEEventNotHandled;
  2879.     myDirObj.dataHandle  = nil;
  2880.     tokenDesc.dataHandle = nil;
  2881.  
  2882.     /*
  2883.         pick up direct object, i.e. the window in which to show the selection
  2884.     */
  2885.  
  2886.     myErr  =
  2887.         AEGetParamDesc(
  2888.             theAppleEvent,
  2889.             keyDirectObject,
  2890.             typeWildCard,
  2891.             &myDirObj);
  2892.  
  2893.     /*
  2894.         missing any parameters?
  2895.     */
  2896.  
  2897.     myErr = GotRequiredParams(theAppleEvent);
  2898.  
  2899.     /*
  2900.         convert object to WindowToken which we understand
  2901.     */
  2902.     myErr = AEResolve(&myDirObj, kAEIDoMinimum, &tokenDesc);
  2903.  
  2904.     if (!myErr)
  2905.         switch (tokenDesc.descriptorType) {
  2906.         case typeMyWndw:
  2907.             GetRawDataFromDescriptor(
  2908.                 &tokenDesc,
  2909.                 (Ptr)&theWindowToken,
  2910.                 sizeof(theWindowToken),
  2911.                 &actSize);
  2912.  
  2913.             if (theWindowToken)
  2914.                 SelectWindow(theWindowToken);
  2915.             else
  2916.                 myErr = errAEIllegalIndex;
  2917.             
  2918.             break;
  2919.         case typeMyText:
  2920.             myErr =
  2921.                 SetSelectionOfAppleEventObject(
  2922.                     keyDirectObject,
  2923.                     theAppleEvent,
  2924.                     &theDocument,
  2925.                     &theHTE);
  2926.             break;
  2927.         default:
  2928.             myErr = errAEEventNotHandled;
  2929.             break;
  2930.         }
  2931.  
  2932.     if (myDirObj.dataHandle)
  2933.         ignoreErr = AEDisposeDesc(&myDirObj);
  2934.  
  2935.     if (tokenDesc.dataHandle)
  2936.         ignoreErr = AEDisposeDesc(&tokenDesc);
  2937.  
  2938.     return myErr;
  2939. }    /* HandleSelect */
  2940.  
  2941. pascal OSErr HandleStartRecording(
  2942.     const AppleEvent *theAppleEvent,
  2943.     AppleEvent *reply,
  2944.     long       handlerRefCon)
  2945. {
  2946. #if !defined(powerc) && !defined(__powerc)
  2947. #pragma unused (reply,handlerRefCon)
  2948. #endif
  2949.  
  2950.     OSErr myErr;
  2951.  
  2952.     gBigBrother++;
  2953.  
  2954.     myErr = GotRequiredParams(theAppleEvent);
  2955.  
  2956.     return myErr;
  2957.  
  2958. }    /* HandleStartRecording */
  2959.  
  2960. pascal OSErr HandleStopRecording(
  2961.     const AppleEvent *theAppleEvent,
  2962.     AppleEvent *reply,
  2963.     long handlerRefCon)
  2964. {
  2965. #if !defined(powerc) && !defined(__powerc)
  2966. #pragma unused (theAppleEvent,reply,handlerRefCon)
  2967. #endif
  2968.  
  2969.     gBigBrother--;
  2970.     return noErr;
  2971. }    /* HandleStopRecording */
  2972.  
  2973.  
  2974. #if !defined(powerc) && !defined(__powerc)
  2975. #pragma segment AECommandIssuers
  2976. #endif
  2977.  
  2978. /*******************************************************************************/
  2979. /*
  2980.         Start of section involved in building and sending AppleEvent Objects as/with
  2981.         commands
  2982.  */
  2983.  
  2984. /*
  2985.     Make an AEDesc that describes the selection in the window and text edit
  2986.     record supplied
  2987. */
  2988.  
  2989. pascal OSErr MakeWindowObj(
  2990.     WindowPtr theWindow,
  2991.     AEDesc    *dMyDoc)
  2992. {
  2993.       WindowPtr searchWindow;
  2994.     short         index;
  2995.     
  2996.     searchWindow = (WindowPtr)LMGetWindowList();
  2997.  
  2998.     /* iterate through windows */
  2999.  
  3000.     for (index = 1; searchWindow; ++index)
  3001.         if (searchWindow == theWindow)
  3002.             break;
  3003.         else
  3004.             searchWindow = (WindowPtr)((WindowPeek)searchWindow)->nextWindow;
  3005.  
  3006.     if (searchWindow == theWindow) 
  3007.         return AEBuild(
  3008.                     dMyDoc, 
  3009.                     "obj{want: type('docu'), form: 'indx', seld: long(@), from: ()}",
  3010.                     index);
  3011.     else {
  3012.         char   windowName[256];
  3013.         
  3014.         getwtitle(theWindow, windowName);
  3015.         
  3016.         return AEBuild(
  3017.                     dMyDoc, 
  3018.                     "obj{want: type('docu'), form: 'name', seld: TEXT(@), from: ()}",
  3019.                     windowName);
  3020.     }
  3021. } /*MakeWindowObj*/
  3022.  
  3023. pascal OSErr MakeTextObj(
  3024.     WindowPtr theWindow,
  3025.     short     selStart,
  3026.     short     selEnd,
  3027.     AEDesc    *selTextObj)
  3028. {
  3029.     OSErr    myErr;
  3030.     OSErr    ignoreErr;
  3031.     AEDesc   dMyDoc;
  3032.     AEDesc   startOfs;
  3033.     AEDesc   endOfs;
  3034.     AEDesc   startObj;
  3035.     AEDesc   endObj;
  3036.     AEDesc   rangeDesc;
  3037.     long     startChar;
  3038.     long     endChar;
  3039.     Boolean  spotFlag;
  3040.  
  3041.     myErr = noErr;
  3042.  
  3043.     if (theWindow==nil)
  3044.         return noErr;
  3045.  
  3046.     selTextObj->dataHandle = nil;
  3047.     dMyDoc.dataHandle      = nil;
  3048.     startObj.dataHandle    = nil;
  3049.     endObj.dataHandle      = nil;
  3050.  
  3051.     /*
  3052.         make the window object
  3053.     */
  3054.  
  3055.     if (myErr = MakeWindowObj(theWindow, &dMyDoc))
  3056.         return myErr;
  3057.  
  3058.     /* get the start and end of selection */
  3059.  
  3060.     startChar = selStart+1;    /* start counting obj's from 1, not 0 */
  3061.     endChar   = selEnd;
  3062.     spotFlag  = (selStart == selEnd);
  3063.  
  3064.     if (myErr = CreateOffsetDescriptor(startChar, &startOfs))
  3065.         return noErr;
  3066.  
  3067.     if (spotFlag)
  3068.         myErr =
  3069.             CreateObjSpecifier(
  3070.                 cSpot,
  3071.                 &dMyDoc,
  3072.                 formAbsolutePosition,
  3073.                 &startOfs,
  3074.                 true,
  3075.                 selTextObj);
  3076.     else {
  3077.         /* not a spot - must represent as range */
  3078.         /* make obj for start char */
  3079.  
  3080.         myErr =
  3081.             CreateObjSpecifier(
  3082.                 cChar,
  3083.                 &dMyDoc,
  3084.                 formAbsolutePosition,
  3085.                 &startOfs,
  3086.                 false,
  3087.                 &startObj);
  3088.  
  3089.         if (myErr==noErr)
  3090.             myErr = CreateOffsetDescriptor(endChar, &endOfs);
  3091.  
  3092.         if (myErr==noErr)
  3093.             myErr =
  3094.                 CreateObjSpecifier(
  3095.                     cChar,
  3096.                     &dMyDoc,
  3097.                     formAbsolutePosition,
  3098.                     &endOfs,
  3099.                     false,
  3100.                     &endObj);
  3101.  
  3102.         if (myErr==noErr)
  3103.             myErr = CreateRangeDescriptor(&startObj, &endObj, false, &rangeDesc);
  3104.  
  3105.         if (myErr==noErr)
  3106.             myErr = CreateObjSpecifier(cChar, &dMyDoc, formRange, &rangeDesc, true, selTextObj);
  3107.  
  3108.         if (startObj.dataHandle)
  3109.           ignoreErr = AEDisposeDesc(&startObj);
  3110.  
  3111.         if (startOfs.dataHandle)
  3112.           ignoreErr = AEDisposeDesc(&startOfs);
  3113.  
  3114.         if (endObj.dataHandle)
  3115.           ignoreErr = AEDisposeDesc(&endObj);
  3116.  
  3117.         if (endOfs.dataHandle)
  3118.           ignoreErr = AEDisposeDesc(&endOfs);
  3119.     }
  3120.  
  3121.     return myErr;
  3122. }
  3123.  
  3124. pascal OSErr MakeSelectedTextObj(
  3125.     WindowPtr theWindow,
  3126.     TEHandle  theTextEditHandle,
  3127.     AEDesc    *selTextObj)
  3128. {
  3129.     return
  3130.         MakeTextObj(
  3131.             theWindow,
  3132.             (**theTextEditHandle).selStart,
  3133.             (**theTextEditHandle).selEnd,
  3134.             selTextObj);
  3135.  
  3136. }    /* MakeSelectedTextObj */
  3137.  
  3138. enum editCommandType {
  3139. editCutCommand   = 1,
  3140. editCopyCommand  = 2,
  3141. editPasteCommand = 3,
  3142. editClearCommand = 4
  3143. };
  3144.  
  3145. typedef enum editCommandType editCommandType;
  3146.  
  3147. pascal void DoEditCommand(DPtr theDocument,editCommandType whatCommand)
  3148. {
  3149.       OSErr         err;
  3150.       OSErr         forgetErr;
  3151.     AEAddressDesc ourAddress;
  3152.     AppleEvent    editCommandEvent;
  3153.     AppleEvent    ignoreReply;
  3154.     AEDesc        ourTextSelObj;
  3155.     AEEventID     theEventID;
  3156.     AEEventClass  theEventClass;
  3157.  
  3158.     /*
  3159.             Initialise
  3160.     */
  3161.  
  3162.     ourAddress.dataHandle             = nil;
  3163.     ourTextSelObj.dataHandle         = nil;
  3164.     editCommandEvent.dataHandle     = nil;
  3165.     ignoreReply.dataHandle             = nil;
  3166.  
  3167.     err = MakeSelfAddress(&ourAddress);
  3168.  
  3169.     /*
  3170.         Build an object to represent the current document's selection
  3171.     */
  3172.     err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &ourTextSelObj);
  3173.  
  3174.     if (err==noErr) {
  3175.         switch (whatCommand) {
  3176.         case  editCutCommand:
  3177.             theEventID    = kAECut;
  3178.             theEventClass = kAEMiscStandards;
  3179.             break;
  3180.         case  editCopyCommand:
  3181.             theEventID    = kAECopy;
  3182.             theEventClass = kAEMiscStandards;
  3183.             break;
  3184.         case  editPasteCommand:
  3185.             theEventID    = kAEPaste;
  3186.             theEventClass = kAEMiscStandards;
  3187.             break;
  3188.         case  editClearCommand:
  3189.             theEventID    = kAEDelete;
  3190.             theEventClass = kAECoreSuite;
  3191.             break;
  3192.         }
  3193.  
  3194.         err = AECreateAppleEvent( theEventClass, theEventID, &ourAddress, 0, 0, &editCommandEvent);
  3195.  
  3196.         /* add parameter */
  3197.         if (err==noErr)
  3198.             err = AEPutParamDesc(&editCommandEvent, keyDirectObject, &ourTextSelObj);
  3199.  
  3200.         /*and now Send the message*/
  3201.         if (err==noErr)
  3202.             err = AESend(&editCommandEvent,&ignoreReply,kAENoReply,kAEHighPriority,10000,nil, nil);
  3203.     }
  3204.  
  3205.     /*
  3206.         Clean up
  3207.     */
  3208.     if (ourAddress.dataHandle)
  3209.         forgetErr = AEDisposeDesc(&ourAddress);
  3210.  
  3211.     if (editCommandEvent.dataHandle)
  3212.         forgetErr = AEDisposeDesc(&editCommandEvent);
  3213.  
  3214.     if (ignoreReply.dataHandle)
  3215.         forgetErr = AEDisposeDesc(&ignoreReply);
  3216.  
  3217.     if (ourTextSelObj.dataHandle)
  3218.         forgetErr = AEDisposeDesc(&ourTextSelObj);
  3219.  
  3220. } /*DoEditCommand*/
  3221.  
  3222. #endif
  3223.  
  3224. pascal void IssueCutCommand(DPtr theDocument)
  3225. {
  3226. #ifndef RUNTIME
  3227.     DoEditCommand(theDocument, editCutCommand);
  3228. #else
  3229.     if (theDocument->kind != kDocumentWindow)
  3230.         if (    !theDocument->u.cons.selected 
  3231.             || (*theDocument->theText)->selStart < theDocument->u.cons.fence
  3232.         ) {
  3233.             if (AllSelected(theDocument->theText)) {
  3234.                 if (theDocument->u.cons.fence < 32767)
  3235.                     theDocument->u.cons.fence = 0;
  3236.             } else {
  3237.                 SysBeep(1);
  3238.                 
  3239.                 IssueCopyCommand(theDocument);
  3240.                 
  3241.                 return;
  3242.             }
  3243.         }
  3244.  
  3245.     ZeroScrap();
  3246.     TECut(theDocument->theText);
  3247.     TEToScrap();
  3248.     AdjustScrollbars(theDocument, false);
  3249.     DrawPageExtras(theDocument);
  3250.     theDocument->dirty = true;
  3251. #endif
  3252. }
  3253.  
  3254. pascal void IssueCopyCommand(DPtr theDocument)
  3255. {
  3256. #ifndef RUNTIME
  3257.     DoEditCommand(theDocument, editCopyCommand);
  3258. #else
  3259.     ZeroScrap();
  3260.     TECopy(theDocument->theText);
  3261.     TEToScrap();
  3262. #endif
  3263. }
  3264.  
  3265. pascal void IssuePasteCommand(DPtr theDocument)
  3266. {
  3267. #ifndef RUNTIME
  3268.     DoEditCommand(theDocument, editPasteCommand);
  3269. #else
  3270.     if (theDocument->kind != kDocumentWindow)
  3271.         if (    !theDocument->u.cons.selected
  3272.             || (*theDocument->theText)->selStart < theDocument->u.cons.fence
  3273.         ) {
  3274.             SysBeep(1);
  3275.             
  3276.             return;
  3277.         }
  3278.     
  3279.     TEFromScrap();
  3280.     TEPaste(theDocument->theText);
  3281.     EnforceMemory(theDocument, theDocument->theText);
  3282.     AdjustScrollbars(theDocument, false);
  3283.     DrawPageExtras(theDocument);
  3284.         
  3285.     theDocument->dirty = true;
  3286. #endif
  3287. }
  3288.  
  3289. pascal void IssueClearCommand(DPtr theDocument)
  3290. {
  3291. #ifndef RUNTIME
  3292.     DoEditCommand(theDocument, editClearCommand);
  3293. #else
  3294.     if (theDocument->kind != kDocumentWindow)
  3295.         if (    !theDocument->u.cons.selected
  3296.             || (*theDocument->theText)->selStart < theDocument->u.cons.fence
  3297.         ) {
  3298.             if (AllSelected(theDocument->theText)) {
  3299.                 if (theDocument->u.cons.fence < 32767)
  3300.                     theDocument->u.cons.fence = 0;
  3301.             } else {
  3302.                 SysBeep(1);
  3303.             
  3304.                 return;
  3305.             }
  3306.         }
  3307.         
  3308.     TEDelete(theDocument->theText);
  3309.     AdjustScrollbars(theDocument, false);
  3310.     DrawPageExtras(theDocument);
  3311.     theDocument->dirty = true;
  3312. #endif
  3313. }
  3314.  
  3315. pascal OSErr IssueJumpCommand(FSSpec * file, WindowPtr win, short line)
  3316. {
  3317.     OSErr                        err;
  3318.     AEDesc                    window;
  3319.     AEDesc                    target;
  3320.     AppleEvent                ignoreReply;
  3321.     ProcessSerialNumber     psn;
  3322.     DescType                    type;
  3323.     Size                        size;
  3324.     
  3325.     MakeSelfPSN(&psn);
  3326.  
  3327.     if (win) {
  3328.         if (err = MakeWindowObj(win, &window))
  3329.             return err;
  3330.             
  3331.         err = AEBuildAppleEvent(kAEMiscStandards, kAESelect,
  3332.                     typeProcessSerialNumber, &psn, sizeof(ProcessSerialNumber),
  3333.                     0, 0, &target,
  3334.                     "'----': @",
  3335.                     &window);
  3336.         
  3337.         AEDisposeDesc(&window);
  3338.         
  3339.         if (err)
  3340.             return err;
  3341.             
  3342.         err = AESend(&target,&ignoreReply,kAENoReply,kAEHighPriority,10000,nil,nil);
  3343.     
  3344.         AEDisposeDesc(&target);
  3345.  
  3346.         if (ignoreReply.dataHandle)
  3347.             AEDisposeDesc(&ignoreReply);    
  3348.  
  3349.         if (err)
  3350.             return err;
  3351.     } else if (file) {
  3352.         if (err = IssueAEOpenDoc(*file))
  3353.             return err;
  3354.     }
  3355.  
  3356.     if (!line)
  3357.         return noErr;
  3358.         
  3359.     if (err = AEBuildAppleEvent(kAEMiscStandards, kAESelect,
  3360.         typeProcessSerialNumber, &psn, sizeof(ProcessSerialNumber),
  3361.         0, 0, &target,
  3362.         "'----': obj{ "
  3363.                      "want: type(clin),"
  3364.                      "form: indx,"
  3365.                      "seld: long(@),"
  3366.                      "from: obj{"
  3367.                                   "want: type(cwin),"
  3368.                                   "form: indx,"
  3369.                                   "seld: long(1),"
  3370.                                   "from: ()"
  3371.                                  "}"
  3372.                     "}",
  3373.         line
  3374.         )
  3375.     )
  3376.         return err;
  3377.  
  3378.     err = AESend(&target,&ignoreReply,kAENoReply,kAEHighPriority,10000,nil,nil);
  3379.     
  3380.     AEDisposeDesc(&target);
  3381.  
  3382.     if (ignoreReply.dataHandle)
  3383.         AEDisposeDesc(&ignoreReply);    
  3384.  
  3385.     return err;
  3386. }
  3387.  
  3388. /*
  3389.     Window property routines
  3390. */
  3391.  
  3392. pascal void IssueZoomCommand(WindowPtr whichWindow, short whichPart)
  3393. {
  3394. #ifndef RUNTIME
  3395.       Boolean       zoomBool;
  3396.     AEDesc        zoomDesc;
  3397.     AEAddressDesc selfAddr;
  3398.     AEDesc        frontWinObj;
  3399.     OSErr         err;
  3400.  
  3401.     err = MakeSelfAddress(&selfAddr);
  3402.     err = MakeWindowObj(whichWindow, &frontWinObj);
  3403.  
  3404.     zoomBool = (whichPart==inZoomOut);
  3405.  
  3406.     err = AECreateDesc(typeBoolean, (Ptr)&zoomBool, sizeof(zoomBool), &zoomDesc);
  3407.     err = SendAESetObjProp(&frontWinObj, pIsZoomed, &zoomDesc, &selfAddr);
  3408. #else
  3409.     ZoomWindow(whichWindow, whichPart, false);
  3410.  
  3411.     ResizeWindow(DPtrFromWindowPtr(whichWindow));
  3412. #endif
  3413. } /* IssueZoomCommand */
  3414.  
  3415. pascal void IssueCloseCommand(WindowPtr whichWindow)
  3416. {
  3417. #ifndef RUNTIME
  3418.     AEAddressDesc  selfAddr;
  3419.     AEDesc         frontWinObj;
  3420.     OSErr          err;
  3421.     OSErr          ignoreErr;
  3422.     AppleEvent     closeCommandEvent;
  3423.     AppleEvent     ignoreReply;
  3424.  
  3425.     frontWinObj.dataHandle = nil;
  3426.  
  3427.     err = MakeSelfAddress(&selfAddr);
  3428.     err = MakeWindowObj(whichWindow, &frontWinObj);
  3429.     err = AECreateAppleEvent( kAECoreSuite, kAEClose, &selfAddr, 0, 0, &closeCommandEvent) ;
  3430.  
  3431.     /* add parameter - the window to close */
  3432.     if (err==noErr)
  3433.         err = AEPutParamDesc(&closeCommandEvent, keyDirectObject, &frontWinObj);
  3434.  
  3435.     if (err==noErr)
  3436.         err = AESend(&closeCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAEHighPriority,10000,nil, nil);
  3437.  
  3438.     if (closeCommandEvent.dataHandle)
  3439.         ignoreErr = AEDisposeDesc(&closeCommandEvent);
  3440.  
  3441.     if (selfAddr.dataHandle)
  3442.         ignoreErr = AEDisposeDesc(&selfAddr);
  3443.  
  3444.     if (frontWinObj.dataHandle)
  3445.         ignoreErr = AEDisposeDesc(&frontWinObj);
  3446. #else
  3447.     DoClose(whichWindow, true, kAEAsk);
  3448. #endif
  3449. } /* IssueCloseCommand */
  3450.  
  3451. pascal void IssueSizeWindow(WindowPtr whichWindow, short newHSize, short newVSize)
  3452. {
  3453. #ifndef RUNTIME
  3454.       Rect          sizeRect;
  3455.     Rect          contentRect;
  3456.     short         edgeSize;
  3457.     AEDesc        sizeDesc;
  3458.     AEAddressDesc selfAddr;
  3459.     AEDesc        frontWinObj;
  3460.     OSErr         err;
  3461.  
  3462.     sizeRect    = (**(((WindowPeek)whichWindow)->strucRgn)).rgnBBox;
  3463.     contentRect = (**(((WindowPeek)whichWindow)->contRgn)).rgnBBox;
  3464.  
  3465.     edgeSize = sizeRect.right-sizeRect.left-(contentRect.right-contentRect.left);
  3466.     sizeRect.right = sizeRect.left+newHSize+edgeSize;
  3467.  
  3468.     edgeSize = sizeRect.bottom-sizeRect.top-(contentRect.bottom-contentRect.top);
  3469.     sizeRect.bottom = sizeRect.top+newVSize+edgeSize;
  3470.  
  3471.     err = MakeSelfAddress(&selfAddr);
  3472.  
  3473.     err = MakeWindowObj(whichWindow, &frontWinObj);
  3474.  
  3475.     if (err==noErr)
  3476.         err =
  3477.             AECreateDesc(
  3478.                 typeQDRectangle,
  3479.                 (Ptr)&sizeRect,
  3480.                 sizeof(sizeRect),
  3481.                 &sizeDesc);
  3482.  
  3483.     if (err==noErr)
  3484.         err =
  3485.             SendAESetObjProp(
  3486.                 &frontWinObj,
  3487.                 pBounds,
  3488.                 &sizeDesc,
  3489.                 &selfAddr);
  3490. #else
  3491.     ResizeWindow(DPtrFromWindowPtr(whichWindow));
  3492. #endif
  3493. } /*IssueSizeWindow*/
  3494.  
  3495. pascal void IssueMoveWindow(WindowPtr whichWindow, Rect sizeRect)
  3496. {
  3497. #ifndef RUNTIME
  3498.     AEDesc        sizeDesc;
  3499.     AEAddressDesc selfAddr;
  3500.     AEDesc        frontWinObj;
  3501.     OSErr         err;
  3502.  
  3503.     err = MakeSelfAddress(&selfAddr);
  3504.     err = MakeWindowObj(whichWindow, &frontWinObj);
  3505.  
  3506.     if (err==noErr)
  3507.         err = AECreateDesc(typeQDRectangle, (Ptr)&sizeRect, sizeof(sizeRect), &sizeDesc);
  3508.  
  3509.     if (err==noErr)
  3510.         err = SendAESetObjProp(&frontWinObj, pBounds, &sizeDesc, &selfAddr);
  3511. #else
  3512.     /* Everything is all right already */
  3513. #endif
  3514. } /*IssueMoveWindow*/
  3515.  
  3516. pascal void IssuePageSetupWindow(WindowPtr whichWindow, TPrint thePageSetup)
  3517. {
  3518. #ifndef RUNTIME
  3519.     AEDesc        sizeDesc;
  3520.     AEAddressDesc selfAddr;
  3521.     AEDesc        frontWinObj;
  3522.     OSErr         err;
  3523.  
  3524.     err = MakeSelfAddress(&selfAddr);
  3525.  
  3526.     err = MakeWindowObj(whichWindow, &frontWinObj);
  3527.  
  3528.     if (err==noErr)
  3529.         err = AECreateDesc(typeTPrint, (Ptr)&thePageSetup, sizeof(thePageSetup), &sizeDesc);
  3530.  
  3531.     if (err==noErr)
  3532.         err = SendAESetObjProp(&frontWinObj, pPageSetup, &sizeDesc, &selfAddr);
  3533. #else
  3534.     /* Everything is all right already */
  3535. #endif
  3536. } /*IssuePageSetupWindow*/
  3537.  
  3538. #ifndef RUNTIME
  3539. pascal void IssueShowBorders(WindowPtr whichWindow, Boolean showBorders)
  3540. {
  3541.     AEDesc        sizeDesc;
  3542.     AEAddressDesc selfAddr;
  3543.     AEDesc        frontWinObj;
  3544.     OSErr         err;
  3545.  
  3546.     err = MakeSelfAddress(&selfAddr);
  3547.  
  3548.     err = MakeWindowObj(whichWindow, &frontWinObj);
  3549.  
  3550.     if (err==noErr)
  3551.         err = AECreateDesc(typeBoolean, (Ptr)&showBorders, sizeof(showBorders), &sizeDesc);
  3552.  
  3553.     if (err==noErr)
  3554.         err = SendAESetObjProp(&frontWinObj, pShowBorders, &sizeDesc, &selfAddr);
  3555. } /*IssueShowBorders*/
  3556. #endif
  3557.  
  3558. pascal void IssuePrintWindow(WindowPtr whichWindow)
  3559. {
  3560. #ifndef RUNTIME
  3561.     AEAddressDesc selfAddr;
  3562.     AEDesc        frontWinObj;
  3563.     OSErr         err;
  3564.     OSErr         ignoreErr;
  3565.     AppleEvent    printCommandEvent;
  3566.     AppleEvent    ignoreReply;
  3567.  
  3568.     err = MakeSelfAddress(&selfAddr);
  3569.  
  3570.     err = MakeWindowObj(whichWindow, &frontWinObj);
  3571.  
  3572.     err = AECreateAppleEvent(kCoreEventClass, kAEPrintDocuments, &selfAddr, 0, 0, &printCommandEvent) ;
  3573.  
  3574.     /*
  3575.         add parameter - the window to print
  3576.     */
  3577.  
  3578.     if (err==noErr)
  3579.         err = AEPutParamDesc(&printCommandEvent, keyDirectObject, &frontWinObj);
  3580.  
  3581.     if (err==noErr)
  3582.         err = AESend(&printCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAEHighPriority,10000,nil, nil);
  3583.  
  3584.       if (printCommandEvent.dataHandle)
  3585.         ignoreErr = AEDisposeDesc(&printCommandEvent);
  3586.  
  3587.     if (frontWinObj.dataHandle)
  3588.         err = AEDisposeDesc(&frontWinObj);
  3589.  
  3590.     if (selfAddr.dataHandle)
  3591.         err = AEDisposeDesc(&selfAddr);
  3592. #else
  3593.     PrintWindow(DPtrFromWindowPtr(whichWindow), true);
  3594. #endif
  3595. } /*IssuePrintWindow*/
  3596.  
  3597. pascal OSErr IssueAEOpenDoc(FSSpec myFSSpec)
  3598. /* send OpenDocs AppleEvent to myself, with a one-element list
  3599.   containing the given file spec
  3600.  
  3601.   NOTES : the core AEOpenDocs event is defined as taking a list of
  3602.           aliases (not file specs) as its direct parameter.  However,
  3603.             we can send the file spec instead and depend on AppleEvents'
  3604.             automatic coercion.  In fact, we don't really even have to put
  3605.             in a list; AppleEvents will coerce a descriptor into a 1-element
  3606.             list if called for.  In this routine, though, we'll make the
  3607.             list for demonstration purposes.
  3608. */
  3609.  
  3610. {
  3611. #ifndef RUNTIME
  3612.     AppleEvent    myAppleEvent;
  3613.     AppleEvent    defReply;
  3614.     AEDescList    docList;
  3615.     AEAddressDesc selfAddr;
  3616.     OSErr         myErr;
  3617.     OSErr         ignoreErr;
  3618.  
  3619.     myAppleEvent.dataHandle = nil;
  3620.     docList.dataHandle  = nil;
  3621.     selfAddr.dataHandle = nil;
  3622.     defReply.dataHandle = nil;
  3623.  
  3624.     /*
  3625.         Create empty list and add one file spec
  3626.     */
  3627.     myErr = AECreateList(nil,0,false, &docList);
  3628.  
  3629.     if (myErr==noErr)
  3630.         myErr = AEPutPtr(&docList,1,typeFSS,(Ptr)&myFSSpec,sizeof(myFSSpec));
  3631.  
  3632.     /*
  3633.         Create a self address to send it to
  3634.     */
  3635.     if (myErr==noErr)
  3636.         myErr = MakeSelfAddress(&selfAddr);
  3637.  
  3638.     if (myErr==noErr)
  3639.         myErr =
  3640.             AECreateAppleEvent(
  3641.                 MPAppSig,
  3642.                 kAEOpenDocuments,
  3643.                 &selfAddr,
  3644.                 kAutoGenerateReturnID,
  3645.                 kAnyTransactionID,
  3646.                 &myAppleEvent);
  3647.  
  3648.     /*
  3649.         Put Params into our event and send it
  3650.     */
  3651.     if (myErr == noErr)
  3652.         myErr =
  3653.             AEPutParamDesc(
  3654.                 &myAppleEvent,
  3655.                 keyDirectObject,
  3656.                 &docList);
  3657.  
  3658.     myErr =
  3659.         AESend(
  3660.             &myAppleEvent,
  3661.             &defReply,
  3662.             kAENoReply+kAEAlwaysInteract,
  3663.             kAENormalPriority,
  3664.             kAEDefaultTimeout,
  3665.             nil,
  3666.             nil);
  3667.  
  3668.     if (selfAddr.dataHandle)
  3669.         ignoreErr = AEDisposeDesc(&selfAddr);
  3670.  
  3671.     if (myAppleEvent.dataHandle)
  3672.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  3673.  
  3674.     if (docList.dataHandle)
  3675.         ignoreErr = AEDisposeDesc(&docList);
  3676.  
  3677.     return myErr;
  3678. #else
  3679.     DocType        type;
  3680.  
  3681.     switch (type = GetDocType(&myFSSpec)) {
  3682.     case kPlainTextDoc:
  3683.     case kScriptDoc:
  3684.     case kRuntime6Doc:
  3685.     case kOldRuntime6Doc:
  3686.     case kRuntime7Doc:
  3687.     default:
  3688.         return OpenOld(myFSSpec, type);
  3689.     case kPreferenceDoc:
  3690.     case kUnknownDoc:
  3691.         SysBeep(1);
  3692.         
  3693.         return errAEEventNotHandled;
  3694.     }
  3695. #endif
  3696. }    /* IssueAEOpenDoc */
  3697.  
  3698. pascal void IssueAENewWindow(void)
  3699. /*
  3700.     send the New Element event to myself with a null container
  3701. */
  3702. {
  3703. #ifndef RUNTIME
  3704.     AppleEvent    myAppleEvent;
  3705.     AppleEvent    defReply;
  3706.     AEAddressDesc selfAddr;
  3707.     OSErr         myErr;
  3708.     OSErr         ignoreErr;
  3709.     DescType      elemClass;
  3710.  
  3711.     myAppleEvent.dataHandle = nil;
  3712.  
  3713.     /*
  3714.         Create the address of us
  3715.     */
  3716.  
  3717.     myErr = MakeSelfAddress(&selfAddr);
  3718.  
  3719.     /*
  3720.         create event
  3721.     */
  3722.  
  3723.     myErr =
  3724.         AECreateAppleEvent(
  3725.             kAECoreSuite,
  3726.             kAECreateElement,
  3727.             &selfAddr,
  3728.             kAutoGenerateReturnID,
  3729.             kAnyTransactionID,
  3730.             &myAppleEvent);
  3731.  
  3732.     /*
  3733.         attach desired class of new element
  3734.     */
  3735.  
  3736.     elemClass = cDocument;
  3737.  
  3738.     if (myErr == noErr)
  3739.         myErr =
  3740.             AEPutParamPtr(
  3741.                 &myAppleEvent,
  3742.                 keyAEObjectClass,
  3743.                 typeType,
  3744.                 (Ptr)&elemClass,
  3745.                 sizeof(elemClass));
  3746.  
  3747.     /*
  3748.         send the event
  3749.     */
  3750.  
  3751.     if (myErr == noErr)
  3752.         myErr =
  3753.             AESend(
  3754.                 &myAppleEvent,
  3755.                 &defReply,
  3756.                 kAENoReply+kAENeverInteract,
  3757.                 kAENormalPriority,
  3758.                 kAEDefaultTimeout,
  3759.                 nil,
  3760.                 nil);
  3761.     /*
  3762.         Clean up - reply never created so don't throw away
  3763.     */
  3764.     if (selfAddr.dataHandle)
  3765.         ignoreErr = AEDisposeDesc(&selfAddr);
  3766.  
  3767.     if (myAppleEvent.dataHandle)
  3768.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  3769. #else
  3770.     DPtr    doc;
  3771.     
  3772.     doc = NewDocument(false, kDocumentWindow);
  3773.  
  3774.     if (doc)
  3775.         DoShowWindow(doc->theWindow);
  3776. #endif
  3777. }    /* IssueAENewWindow */
  3778.  
  3779. pascal OSErr IssueSaveCommand(
  3780.     DPtr             theDocument,
  3781.     FSSpecPtr     where)
  3782. /*
  3783.     send an AppleEvent Save Event to myself
  3784. */
  3785. {
  3786. #ifndef RUNTIME
  3787.     AEDesc        windowObj;
  3788.     AppleEvent    myAppleEvent;
  3789.     AppleEvent    defReply;
  3790.     OSErr         myErr;
  3791.     OSErr         ignoreErr;
  3792.     AEAddressDesc selfAddr;
  3793.  
  3794.     windowObj.dataHandle = nil;
  3795.     myAppleEvent.dataHandle = nil;
  3796.  
  3797.     myErr = MakeWindowObj(theDocument->theWindow, &windowObj);
  3798.  
  3799.     if (myErr==noErr)
  3800.         myErr = MakeSelfAddress(&selfAddr);
  3801.  
  3802.   /*
  3803.         Build event
  3804.     */
  3805.   if (myErr == noErr)
  3806.         myErr =
  3807.             AECreateAppleEvent(
  3808.                 kAECoreSuite,
  3809.                 kAESave,
  3810.                 &selfAddr,
  3811.                 kAutoGenerateReturnID,
  3812.                 kAnyTransactionID,
  3813.                 &myAppleEvent);
  3814.  
  3815.   /*
  3816.         say which window
  3817.     */
  3818.   if (myErr==noErr)
  3819.         myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, &windowObj);
  3820.  
  3821.   /*
  3822.         add optional file param if we need to
  3823.     */
  3824.   if (where)
  3825.         if (myErr==noErr)
  3826.             myErr =
  3827.                 AEPutParamPtr(
  3828.                     &myAppleEvent,
  3829.                     keyAEDestination,
  3830.                     typeFSS,
  3831.                     (Ptr)where,
  3832.                     sizeof(FSSpec));
  3833.  
  3834.     if (!myErr)
  3835.         myErr =
  3836.             AEPutParamPtr(
  3837.                 &myAppleEvent,
  3838.                 keyAEFileType,
  3839.                 typeEnumerated,
  3840.                 (Ptr)&theDocument->type,
  3841.                 sizeof(OSType));
  3842.         
  3843.   /*
  3844.         send the event
  3845.     */
  3846.   if (myErr==noErr)
  3847.         myErr  =
  3848.             AESend(
  3849.                 &myAppleEvent,
  3850.                 &defReply,
  3851.                 kAENoReply+kAENeverInteract,
  3852.                 kAENormalPriority,
  3853.                 kAEDefaultTimeout,
  3854.                 nil,
  3855.                 nil);
  3856.  
  3857.     if (selfAddr.dataHandle)
  3858.         ignoreErr = AEDisposeDesc(&selfAddr);
  3859.  
  3860.     if (windowObj.dataHandle)
  3861.         ignoreErr = AEDisposeDesc(&windowObj);
  3862.  
  3863.     if (myAppleEvent.dataHandle)
  3864.         myErr = AEDisposeDesc(&myAppleEvent);
  3865.  
  3866.     return myErr;
  3867. #else
  3868.     OSErr         myErr;
  3869.     
  3870.     if (where)
  3871.         return SaveWithoutTemp(theDocument, *where);
  3872.     else
  3873.         return SaveUsingTemp(theDocument);
  3874. #endif
  3875. }    /* IssueSaveCommand */
  3876.  
  3877. pascal OSErr IssueRevertCommand(WindowPtr theWindow)
  3878. /*
  3879.     send an AppleEvent Revert Event to myself
  3880. */
  3881. {
  3882. #ifndef RUNTIME
  3883.     AEDesc        windowObj;
  3884.     AppleEvent    myAppleEvent;
  3885.     AppleEvent    defReply;
  3886.     OSErr         myErr;
  3887.     OSErr         ignoreErr;
  3888.     AEAddressDesc selfAddr;
  3889.  
  3890.     windowObj.dataHandle = nil;
  3891.     myAppleEvent.dataHandle = nil;
  3892.  
  3893.     myErr = MakeWindowObj(theWindow, &windowObj);
  3894.  
  3895.     if (myErr==noErr)
  3896.         myErr = MakeSelfAddress(&selfAddr);
  3897.  
  3898.     /*
  3899.         Build event
  3900.     */
  3901.  
  3902.     if (myErr == noErr)
  3903.         myErr  =
  3904.             AECreateAppleEvent(
  3905.                 kAEMiscStandards,
  3906.                 kAERevert,
  3907.                 &selfAddr,
  3908.                 kAutoGenerateReturnID,
  3909.                 kAnyTransactionID,
  3910.                 &myAppleEvent);
  3911.     /*
  3912.         say which window
  3913.     */
  3914.  
  3915.     if (myErr == noErr)
  3916.         myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, &windowObj);
  3917.     /*
  3918.         send the event
  3919.     */
  3920.     if (myErr==noErr)
  3921.         myErr =
  3922.             AESend(
  3923.                 &myAppleEvent,
  3924.                 &defReply,
  3925.                 kAENoReply+kAENeverInteract,
  3926.                 kAENormalPriority,
  3927.                 kAEDefaultTimeout,
  3928.                 nil,
  3929.                 nil);
  3930.  
  3931.     if (windowObj.dataHandle)
  3932.         ignoreErr = AEDisposeDesc(&windowObj);
  3933.  
  3934.     if (myAppleEvent.dataHandle)
  3935.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  3936.  
  3937.     if (selfAddr.dataHandle)
  3938.         ignoreErr = AEDisposeDesc(&selfAddr);
  3939.  
  3940.     return myErr;
  3941. #else
  3942.     OSErr myErr;
  3943.     DPtr     theDoc = DPtrFromWindowPtr(theWindow);
  3944.  
  3945.     if (theDoc->kind != kDocumentWindow)
  3946.         return errAEEventNotHandled;
  3947.     else {
  3948.         HidePen();
  3949.         TESetSelect(0, (*(theDoc->theText))->teLength, theDoc->theText);
  3950.         ShowPen();
  3951.         TEDelete(theDoc->theText);
  3952.  
  3953.         if (theDoc->u.reg.everSaved) {
  3954.             myErr = GetFileContents(theDoc->theFSSpec, theDoc);
  3955.             if (myErr == noErr) {
  3956.                 ResizeWindow(theDoc);
  3957.                 theDoc->dirty = false;
  3958.             }
  3959.         }
  3960.  
  3961.         DoShowWindow(theDoc->theWindow); /* <<< Visible already??? */
  3962.         DoUpdate(theDoc, theDoc->theWindow);
  3963.         
  3964.         return noErr;
  3965.     }
  3966. #endif
  3967. }    /* IssueRevertCommand */
  3968.  
  3969. /*
  3970.     Name : IssueQuitCommand
  3971.     Purpose : Sends self a Quit AppleEvent
  3972. */
  3973. pascal OSErr IssueQuitCommand(void)
  3974. {
  3975. #ifndef RUNTIME
  3976.     AppleEvent    myAppleEvent;
  3977.     AppleEvent    defReply;
  3978.     OSErr         myErr;
  3979.     OSErr         ignoreErr;
  3980.     AEAddressDesc selfAddr;
  3981.     DescType      mySaveOpt;
  3982.  
  3983.     myAppleEvent.dataHandle = nil;
  3984.     selfAddr.dataHandle     = nil;
  3985.  
  3986.     myErr = MakeSelfAddress(&selfAddr);
  3987.  
  3988.     /*
  3989.         Build event
  3990.     */
  3991.     if (myErr == noErr)
  3992.         myErr  =
  3993.             AECreateAppleEvent(
  3994.                 kCoreEventClass,
  3995.                 kAEQuitApplication,
  3996.                 &selfAddr,
  3997.                 kAutoGenerateReturnID,
  3998.                 kAnyTransactionID,
  3999.                 &myAppleEvent);
  4000.     /*
  4001.         say which save option
  4002.     */
  4003.     mySaveOpt = kAEAsk;
  4004.  
  4005.     if (myErr == noErr)
  4006.         myErr =
  4007.             AEPutParamPtr(
  4008.                 &myAppleEvent,
  4009.                 keyAESaveOptions,
  4010.                 typeEnumerated,
  4011.                 (Ptr)&mySaveOpt,
  4012.                 sizeof(mySaveOpt));
  4013.     /*
  4014.         send the event
  4015.     */
  4016.     if (myErr==noErr)
  4017.         myErr =
  4018.             AESend(
  4019.                 &myAppleEvent,
  4020.                 &defReply,
  4021.                 kAENoReply+kAEAlwaysInteract,
  4022.                 kAENormalPriority,
  4023.                 kAEDefaultTimeout,
  4024.                 nil,
  4025.                 nil);
  4026.  
  4027.     if (myAppleEvent.dataHandle)
  4028.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  4029.  
  4030.     if (selfAddr.dataHandle)
  4031.         ignoreErr = AEDisposeDesc(&selfAddr);
  4032.  
  4033.     return myErr;
  4034. #else
  4035.     DoQuit(kAEAsk);
  4036.     
  4037.     return noErr;
  4038. #endif
  4039. }    /* IssueQuitCommand */
  4040.  
  4041. #ifndef RUNTIME
  4042.  
  4043. /*
  4044.      Name :IssueCreatePublisher
  4045.      Purpose :Interact with user to get Publisher info
  4046.                         and the IssueAECommand to Publish currect selection
  4047. */
  4048. pascal void IssueCreatePublisher(DPtr whichDoc)
  4049. {
  4050.     AEAddressDesc selfAddr;
  4051.     AEDesc        selTextObj;
  4052.     OSErr         err;
  4053.     OSErr         ignoreErr;
  4054.     AppleEvent    publishCommandEvent;
  4055.     AppleEvent    ignoreReply;
  4056.  
  4057.       publishCommandEvent.dataHandle = nil;
  4058.     selfAddr.dataHandle = nil;
  4059.     selTextObj.dataHandle = nil;
  4060.  
  4061.     err = MakeSelfAddress(&selfAddr);
  4062.  
  4063.     if (err==noErr)
  4064.         err = MakeSelectedTextObj(whichDoc->theWindow, whichDoc->theText, &selTextObj);
  4065.  
  4066.     err =
  4067.         AECreateAppleEvent(
  4068.             kAEMiscStandards,
  4069.             kAECreatePublisher,
  4070.             &selfAddr,
  4071.             0,
  4072.             0,
  4073.             &publishCommandEvent) ;
  4074.  
  4075.     /*
  4076.         add parameter - the text to publish
  4077.     */
  4078.     if (err==noErr)
  4079.         err = AEPutParamDesc(&publishCommandEvent, keyDirectObject, &selTextObj);
  4080.  
  4081.     if (err==noErr)
  4082.         err =
  4083.             AESend(
  4084.                 &publishCommandEvent,
  4085.                 &ignoreReply,
  4086.                 kAENoReply+kAEAlwaysInteract,
  4087.                 kAEHighPriority,
  4088.                 10000,
  4089.                 nil,
  4090.                 nil);
  4091.  
  4092.       if (publishCommandEvent.dataHandle)
  4093.         ignoreErr = AEDisposeDesc(&publishCommandEvent);
  4094.  
  4095.     if (selTextObj.dataHandle)
  4096.         ignoreErr = AEDisposeDesc(&selTextObj);
  4097.  
  4098.     if (selfAddr.dataHandle)
  4099.         ignoreErr = AEDisposeDesc(&selfAddr);
  4100. } /*IssueCreatePublisher*/
  4101.  
  4102. #endif
  4103.  
  4104. #define kOK 1
  4105. #define kCancel 2
  4106. #define kOtherSize 4
  4107. #define kOutlineItem 5
  4108.  
  4109. pascal Boolean PoseSizeDialog(long *whatSize)
  4110. {
  4111.     GrafPtr   savedPort;
  4112.     DialogPtr aDialog;
  4113.     Str255    aString;
  4114.     short     itemHit;
  4115.  
  4116.     GetPort(&savedPort);
  4117.     aDialog = GetNewDialog(1004, nil, (WindowPtr)-1);
  4118.     DoShowWindow(aDialog);
  4119.     SetPort(aDialog);
  4120.  
  4121.     AdornDefaultButton(aDialog, kOutlineItem);
  4122.  
  4123.     /*set the edittext button to contain the right size*/
  4124.     NumToString(*whatSize, aString);
  4125.     SetText(aDialog, kOtherSize, aString);
  4126.  
  4127.     do {
  4128.         ModalDialog(nil, &itemHit);
  4129.     } while ((itemHit!=kOK) && (itemHit!=kCancel));
  4130.  
  4131.     if (itemHit == kOK)
  4132.         RetrieveText(aDialog, kOtherSize, aString);
  4133.  
  4134.     DisposDialog(aDialog);
  4135.     SetPort(savedPort);
  4136.  
  4137.     if (itemHit == kOK) {
  4138.         /*set the new size of the text*/
  4139.         StringToNum(aString, whatSize);
  4140.         if ((*whatSize<1) || (*whatSize>2000))
  4141.              *whatSize = 12;
  4142.     }
  4143.     return itemHit == kOK;
  4144. }
  4145.  
  4146. pascal void IssueFormatCommand(DPtr theDocument)
  4147. {
  4148.     Str255            name;
  4149. #ifndef RUNTIME
  4150.     AEDesc            desc;
  4151.     AEAddressDesc     theAddress;
  4152.     AEDesc            windowObj;
  4153. #endif
  4154.     OSErr             err;
  4155.     DocFormat        fmt;
  4156.     Boolean            defaultFormat;
  4157.     
  4158.     if (theDocument) {
  4159.         fmt.font         =     (*theDocument->theText)->txFont;
  4160.         fmt.size         =     (*theDocument->theText)->txSize;
  4161.         defaultFormat    =    false;
  4162.     } else {
  4163.         fmt                 =     gFormat;
  4164.         defaultFormat    =    true;
  4165.     }
  4166.     
  4167.     if (DoFormatDialog(&fmt, &defaultFormat)) {
  4168.         if (theDocument) {
  4169. #ifndef RUNTIME
  4170.             err = MakeSelfAddress(&theAddress);
  4171.             err = MakeWindowObj(theDocument->theWindow, &windowObj);
  4172.  
  4173.             if (err==noErr)
  4174.                   err = CreateOffsetDescriptor(fmt.size, &desc);
  4175.  
  4176.             if (err==noErr)
  4177.                 err = SendAESetObjProp(&windowObj, pPointSize, &desc, &theAddress);
  4178.                 
  4179.             err = MakeSelfAddress(&theAddress);
  4180.             err = MakeWindowObj(theDocument->theWindow, &windowObj);
  4181.         
  4182.             GetFontName(fmt.font, name);
  4183.         
  4184.             if (err==noErr)
  4185.                 err  = AECreateDesc(typeChar, (Ptr)&name[1], name[0], &desc);
  4186.         
  4187.             if (err==noErr)
  4188.                 err  = SendAESetObjProp(&windowObj, pFont, &desc, &theAddress);
  4189. #else
  4190.             (*theDocument->theText)->txFont = fmt.font;
  4191.             (*theDocument->theText)->txSize = fmt.size;
  4192.             RecalcFontInfo(theDocument->theText);
  4193.             AdjustScrollbars(theDocument, false);
  4194.             DrawPageExtras(theDocument);
  4195.             
  4196.             if (theDocument->kind == kDocumentWindow)
  4197.                 theDocument->dirty = true;
  4198.  
  4199.             if (theDocument->theWindow == FrontWindow() && !gInBackground)
  4200.                 AdjustScript(theDocument);
  4201. #endif
  4202.         }
  4203.         
  4204.         if (defaultFormat) {
  4205.             gFormat = fmt;
  4206.  
  4207.             if (gPrefsFile) {
  4208.                 short        resFile;
  4209.                 short    **    defaultFont;
  4210.             
  4211.                 resFile = CurResFile();
  4212.                 UseResFile(gPrefsFile);
  4213.                 
  4214.                 defaultFont = (short **) Get1Resource('PFNT', 128);
  4215.                 **defaultFont = gFormat.size;
  4216.                 GetFontName(gFormat.font, name);
  4217.                 SetResInfo((Handle) defaultFont, 128, name);
  4218.                 ChangedResource((Handle) defaultFont);
  4219.                 WriteResource((Handle) defaultFont);
  4220.                 UpdateResFile(gPrefsFile);
  4221.             
  4222.                 UseResFile(resFile);
  4223.             }
  4224.         }
  4225.     }
  4226. } /*IssueFormatCommand*/
  4227.  
  4228. #ifndef RUNTIME
  4229.  
  4230. pascal OSErr IssueSetDataObjToBufferContents(const AEDesc * theObj)
  4231. {
  4232.       OSErr             myErr;
  4233.     OSErr                ignoreErr;
  4234.     AEAddressDesc     theAddress;
  4235.     AppleEvent        myAppleEvent;
  4236.     AppleEvent        defReply;
  4237.  
  4238.     myErr = MakeSelfAddress(&theAddress);
  4239.  
  4240.     /* create event */
  4241.  
  4242.     if (myErr==noErr)
  4243.         myErr = AECreateAppleEvent(kAECoreSuite, kAESetData, &theAddress, 0, 0, &myAppleEvent);
  4244.  
  4245.     /* add prop obj spec to the event */
  4246.  
  4247.     if (myErr==noErr)
  4248.         myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, theObj);
  4249.  
  4250.     /* add prop data to the event */
  4251.  
  4252.     if (myErr==noErr)
  4253.         myErr =
  4254.             AEPutParamPtr(
  4255.                 &myAppleEvent,
  4256.                 keyAEData,
  4257.                 typeChar,
  4258.                 (Ptr)gTypingBuffer,
  4259.                 gCharsInBuffer);
  4260.  
  4261.     /* send event */
  4262.  
  4263.     if (myErr==noErr)
  4264.      if (gRecordingImplemented)
  4265.          myErr =
  4266.              AESend(
  4267.                 &myAppleEvent,
  4268.                 &defReply,
  4269.                 kAENoReply+kAEDontExecute,
  4270.                 kAENormalPriority,
  4271.                 kAEDefaultTimeout,
  4272.                 nil,
  4273.                 nil);
  4274.  
  4275.     if (theAddress.dataHandle)
  4276.         ignoreErr = AEDisposeDesc(&theAddress);
  4277.  
  4278.     if (myAppleEvent.dataHandle)
  4279.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  4280.  
  4281.     return myErr;
  4282. }
  4283.  
  4284. pascal void AddKeyToTypingBuffer(DPtr theDocument, char theKey)
  4285. {
  4286.     OSErr myErr;
  4287.     OSErr ignoreErr;
  4288.  
  4289.     if (theKey==BS || theKey==FS || theKey==GS || theKey==RS || theKey==US) {
  4290.         FlushAndRecordTypingBuffer();
  4291.         if (theKey==BS) {
  4292.             if ((**theDocument->theText).selStart!=(**theDocument->theText).selEnd) {
  4293.                 myErr =
  4294.                     MakeTextObj(
  4295.                         theDocument->theWindow,
  4296.                         (**theDocument->theText).selStart,
  4297.                         (**theDocument->theText).selEnd,
  4298.                         &gTypingTargetObject);
  4299.             } else {
  4300.                 myErr =
  4301.                     MakeTextObj(
  4302.                         theDocument->theWindow,
  4303.                         (**theDocument->theText).selStart-1,
  4304.                         (**theDocument->theText).selStart,
  4305.                         &gTypingTargetObject);
  4306.             }
  4307.  
  4308.              myErr = IssueSetDataObjToBufferContents(&gTypingTargetObject);
  4309.  
  4310.             ignoreErr = AEDisposeDesc(&gTypingTargetObject);
  4311.  
  4312.             gTypingTargetObject.dataHandle = nil;
  4313.         }
  4314.     } else {
  4315.         if (gCharsInBuffer==0)
  4316.             myErr =
  4317.                 MakeSelectedTextObj(
  4318.                     theDocument->theWindow,
  4319.                     theDocument->theText,
  4320.                     &gTypingTargetObject);
  4321.  
  4322.         gTypingBuffer[gCharsInBuffer++] = theKey;
  4323.     }
  4324. }
  4325.  
  4326. pascal void FlushAndRecordTypingBuffer(void)
  4327. {
  4328.       OSErr  myErr;
  4329.     OSErr  ignoreErr;
  4330.  
  4331.     if (gCharsInBuffer != 0) {
  4332.         myErr = IssueSetDataObjToBufferContents(&gTypingTargetObject);
  4333.  
  4334.         if (gTypingTargetObject.dataHandle)
  4335.             ignoreErr = AEDisposeDesc(&gTypingTargetObject);
  4336.     }
  4337.  
  4338.     gCharsInBuffer = 0;
  4339.     gTypingTargetObject.dataHandle = 0;
  4340. }
  4341.  
  4342. /*****************************************************************************/
  4343. /*
  4344.     Object Accessors
  4345. */
  4346.  
  4347. pascal OSErr WindowFromNullAccessor(
  4348.     DescType      wantClass,
  4349.     const AEDesc  *container,
  4350.     DescType      containerClass,
  4351.     DescType      form,
  4352.     const AEDesc  *selectionData,
  4353.     AEDesc        *value,
  4354.     long          theRefCon)
  4355. {
  4356. #if !defined(powerc) && !defined(__powerc)
  4357. #pragma unused (container,theRefCon)
  4358. #endif
  4359.  
  4360.     OSErr       myErr;
  4361.     Str255      nameStr;
  4362.     WindowToken theWindow;
  4363.     short       index;
  4364.     AEDesc      resultDesc;
  4365.  
  4366.     myErr = errAEBadKeyForm;    /* or whatever */
  4367.  
  4368.     value->dataHandle     = nil;
  4369.     resultDesc.dataHandle = nil;
  4370.  
  4371.     /*
  4372.         should only be called with wantClass = cWindow and
  4373.         with containerClass = typeNull or typeMyAppl.
  4374.         Currently accept as either formName or formAbsolutePosition
  4375.     */
  4376.  
  4377.     if (
  4378.         ((wantClass != cWindow) && (wantClass != cDocument)) ||
  4379.         ((containerClass != typeNull) && (containerClass != typeMyAppl)) ||
  4380.         !((form == formName) || (form == formAbsolutePosition))
  4381.     )
  4382.         return errAEWrongDataType;
  4383.  
  4384.     if (form == formName) {
  4385.         myErr     = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  4386.         theWindow = WindowNameToWindowPtr(nameStr);
  4387.     }
  4388.  
  4389.     if (form == formAbsolutePosition) {
  4390.         myErr         = GetIntegerFromDescriptor(selectionData, &index);
  4391.  
  4392.         if (index<0)
  4393.             index = CountWindows()+index+1;
  4394.  
  4395.         theWindow = GetWindowPtrOfNthWindow(index);
  4396.     }
  4397.  
  4398.     if (myErr == noErr)
  4399.         myErr = AECreateDesc(typeMyWndw, (Ptr)&theWindow, sizeof(theWindow), value);
  4400.  
  4401.     return myErr;
  4402. }    /* WindowFromNullAccessor */
  4403.  
  4404. pascal OSErr ApplicationFromNullAccessor(
  4405.     DescType      wantClass,
  4406.     const AEDesc  *container,
  4407.     DescType      containerClass,
  4408.     DescType      form,
  4409.     const AEDesc  *selectionData,
  4410.     AEDesc        *value,
  4411.     long          theRefCon)
  4412. {
  4413. #if !defined(powerc) && !defined(__powerc)
  4414. #pragma unused (container,selectionData,theRefCon)
  4415. #endif
  4416.  
  4417.     OSErr    myErr;
  4418.     appToken theApp;
  4419.     AEDesc   resultDesc;
  4420.  
  4421.     value->dataHandle     = nil;
  4422.     resultDesc.dataHandle = nil;
  4423.  
  4424.     /*
  4425.         should only be called with wantClass = cApplication and
  4426.         with containerClass = typeNull.
  4427.         Currently accept as either formName or formAbsolutePosition
  4428.     */
  4429.  
  4430.     if (
  4431.         (wantClass != cApplication) ||
  4432.         (containerClass != typeNull) ||
  4433.         !((form == formName) || (form == formAbsolutePosition))
  4434.     )
  4435.         return errAEWrongDataType;
  4436.  
  4437.     if ((form == formName) || (form == formAbsolutePosition)) {
  4438.         theApp.highLongOfPSN = 0;
  4439.         theApp.lowLongOfPSN  = kCurrentProcess;
  4440.     }
  4441.  
  4442.     myErr = AECreateDesc(typeMyAppl, (Ptr)&theApp, sizeof(theApp), value);
  4443.  
  4444.     return myErr;
  4445. }    /* ApplicationFromNullAccessor */
  4446.  
  4447. pascal void MoveToNonSpace(short *start, short limit, charsHandle myChars)
  4448. /*
  4449.     Treats space,comma, full stop, ; and : as space chars
  4450. */
  4451. {
  4452.     while (*start<=limit)
  4453.           switch ((**myChars)[*start]) {
  4454.           case ' ':
  4455.         case ',':
  4456.         case '.':
  4457.         case ':':
  4458.         case 10:
  4459.         case 13:
  4460.             (*start) +=1;
  4461.             break;
  4462.         default:
  4463.             return;
  4464.         }
  4465. }
  4466.  
  4467. pascal void MoveToSpace(short *start, short limit, charsHandle myChars)
  4468.     /*
  4469.         Treats space,comma, full stop, ; and : as space chars
  4470.     */
  4471. {
  4472.     while (*start<=limit)
  4473.           switch ((**myChars)[*start]) {
  4474.           case ' ':
  4475.         case ',':
  4476.         case '.':
  4477.         case ':':
  4478.         case 10:
  4479.         case 13:
  4480.             return;
  4481.         default:
  4482.             (*start) +=1;
  4483.             break;
  4484.         }
  4485. }
  4486.  
  4487. pascal short CountWords(TEHandle inTextHandle, short startAt, short forHowManyChars)
  4488. {
  4489.     charsHandle myChars;
  4490.     short       start;
  4491.     short       limit;
  4492.     short       myWords;
  4493.  
  4494.     myChars  = (charsHandle)(**inTextHandle).hText;
  4495.     limit    = startAt+forHowManyChars-1;
  4496.     start    = startAt;
  4497.     myWords  = 0;
  4498.     MoveToNonSpace(&start, limit, myChars);
  4499.     while (start<=limit) {
  4500.         myWords++;
  4501.         MoveToSpace(&start, limit, myChars);
  4502.         MoveToNonSpace(&start, limit, myChars);
  4503.     }
  4504.     return myWords;
  4505. } /* CountWords */
  4506.  
  4507. pascal void GetNthWordInfo(
  4508.     short    whichWord,
  4509.     TEHandle inTextHandle,
  4510.     short    *wordStartChar,
  4511.     short    *wordLength)
  4512.     /*
  4513.         On entry:    wordStartChar is start of char range to count in
  4514.                             wordLength is number of chars to consider
  4515.  
  4516.         On Exit : wordStartChar is start of requested word
  4517.                             wordLength is number of chars in word
  4518.     */
  4519. {
  4520.     charsHandle myChars;
  4521.     short       start;
  4522.     short       limit;
  4523.  
  4524.     myChars  = (charsHandle)(**inTextHandle).hText;
  4525.     limit    = *wordStartChar + *wordLength-1;
  4526.     start    = *wordStartChar;
  4527.     MoveToNonSpace(&start, limit, myChars);
  4528.     while ((start<=limit) && (whichWord>0)) {
  4529.  
  4530.         whichWord       = whichWord-1;
  4531.         *wordStartChar  = start;
  4532.         MoveToSpace(&start, limit, myChars);
  4533.         *wordLength     = start- *wordStartChar;
  4534.  
  4535.         MoveToNonSpace(&start, limit, myChars);
  4536.     }
  4537. } /* GetNthWordInfo */
  4538.  
  4539. pascal void GetWordInfo(
  4540.     short    whichWord,
  4541.     TEHandle inTextHandle,
  4542.     short    *wordStartChar,
  4543.     short    *wordLength)
  4544.     /*
  4545.         On wordStartChar entry is start of char range to count in
  4546.                             wordLength is number of chars to consider
  4547.  
  4548.         On Exit : wordStartChar is start of requested word
  4549.                             wordLength is number of chars in word
  4550.     */
  4551. {
  4552.     short noOfWords;
  4553.  
  4554.     noOfWords = CountWords(inTextHandle, *wordStartChar, *wordLength);
  4555.  
  4556.     if (whichWord<0)
  4557.         whichWord = noOfWords + whichWord + 1;
  4558.  
  4559.     if (whichWord>noOfWords) {
  4560.         *wordStartChar = *wordStartChar+*wordLength;
  4561.         *wordLength    = 0;
  4562.     } else
  4563.         GetNthWordInfo(whichWord, inTextHandle, wordStartChar, wordLength);
  4564. }
  4565.  
  4566. pascal short CountLines(TEHandle inTextHandle)
  4567. {
  4568.     /*
  4569.         CountLines makes use of info in TERec
  4570.     */
  4571.     return (**inTextHandle).nLines;
  4572. }
  4573.  
  4574. pascal short LineOfOffset(TEHandle theHTE, short charOffset)
  4575. {
  4576.     short n;
  4577.  
  4578.     n = (**theHTE).nLines;
  4579.  
  4580.     while (((**theHTE).lineStarts[n-1]>charOffset) &&
  4581.                  (n>0))
  4582.          n--;
  4583.  
  4584.     return n;
  4585. } /* LineOfOffset */
  4586.  
  4587. pascal void GetLineInfo(
  4588.     short    whichLine,
  4589.     TEHandle inTextHandle,
  4590.     short    *lineStartChar,
  4591.     short    *lineLength)
  4592. {
  4593.     short       noOfLines;
  4594.     charsHandle myChars;
  4595.  
  4596.     /* Addition of lines within text object */
  4597.     short       lineOfStart;
  4598.     short       lineOfEnd;
  4599.  
  4600.     lineOfStart = LineOfOffset(inTextHandle, *lineStartChar);
  4601.     lineOfEnd   = LineOfOffset(inTextHandle, *lineStartChar+*lineLength-1);
  4602.  
  4603.     myChars   = (charsHandle)(**inTextHandle).hText;
  4604.     noOfLines = lineOfEnd - lineOfStart + 1;
  4605.  
  4606.     if (whichLine<0)
  4607.         whichLine = noOfLines + whichLine + 1;
  4608.  
  4609.     noOfLines = CountLines(inTextHandle);
  4610.     whichLine = whichLine + lineOfStart - 1; /* convert offset relative to offset absolute */
  4611.  
  4612.     /* End of addition */
  4613.  
  4614.     if (whichLine<=lineOfEnd) {
  4615.         *lineStartChar = (**inTextHandle).lineStarts[whichLine-1];
  4616.         if (whichLine==noOfLines)
  4617.             *lineLength  = (**inTextHandle).teLength;
  4618.         else
  4619.             *lineLength  = (**inTextHandle).lineStarts[whichLine];
  4620.         *lineLength    = *lineLength-*lineStartChar;
  4621.         /*
  4622.             Don't return CR
  4623.         */
  4624.         if ((**myChars)[ *lineStartChar+*lineLength-1] == 13)
  4625.             *lineLength = *lineLength-1;
  4626.     } else {
  4627.         if (whichLine<noOfLines)
  4628.           *lineStartChar = (**inTextHandle).lineStarts[whichLine]; /* start of whichLine++ */
  4629.         else
  4630.             *lineStartChar = (**inTextHandle).teLength;
  4631.         *lineLength    = 0;
  4632.     }
  4633. } /* GetLineInfo */
  4634.  
  4635. pascal OSErr TextElemFromWndwAccessor(
  4636.     DescType     wantClass,
  4637.     const AEDesc *container,
  4638.     DescType     containerClass,
  4639.     DescType     form,
  4640.     const AEDesc *selectionData,
  4641.     AEDesc       *value,
  4642.     long         theRefCon)
  4643. {
  4644. #if !defined(powerc) && !defined(__powerc)
  4645. #pragma unused (theRefCon)
  4646. #endif
  4647.  
  4648.     OSErr       myErr;
  4649.     OSErr       ignoreErr;
  4650.     WindowToken theWindow;
  4651.     Size        actSize;
  4652.     long        index;
  4653.     TextToken   theTextToken;
  4654.     AERecord    selectionRecord;
  4655.     TextToken   startText;
  4656.     TextToken   stopText;
  4657.     DescType    returnedType;
  4658.     AEDesc      windDesc;
  4659.     TEHandle    theHTE;
  4660.     DPtr        theDocument;
  4661.     short       wordStartChar;
  4662.     short       wordLength;
  4663.  
  4664.     myErr = -1700;    /* or whatever */
  4665.  
  4666.     selectionRecord.dataHandle = nil;
  4667.  
  4668.     /* do some checking for robustness' sake */
  4669.  
  4670.     if (
  4671.         ((containerClass != cWindow) && (containerClass != cDocument)) ||
  4672.         ((wantClass != cText) && (wantClass != cChar) && (wantClass != cSpot) && (wantClass != cWord) && (wantClass != cLine)    ) ||
  4673.         ((form!=formRange) && (form!=formAbsolutePosition))
  4674.     )
  4675.         return errAEWrongDataType;
  4676.  
  4677.     /* let's get the window which contains the text element */
  4678.  
  4679.     myErr = AECoerceDesc(container, typeMyWndw, &windDesc);
  4680.     GetRawDataFromDescriptor(&windDesc, (Ptr)&theWindow, sizeof(theWindow), &actSize);
  4681.     myErr = AEDisposeDesc(&windDesc);
  4682.  
  4683.     if (theWindow==nil)
  4684.         myErr = errAEIllegalIndex;
  4685.     else {
  4686.         theTextToken.tokenWindow = theWindow;
  4687.  
  4688.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  4689.         theHTE      = theDocument->theText;
  4690.  
  4691.         switch (form) {
  4692.         case formAbsolutePosition:
  4693.             myErr = GetLongIntFromDescriptor(selectionData, &index);
  4694.  
  4695.             switch (wantClass) {
  4696.             case cSpot:
  4697.                 if (index<0)
  4698.                     theTextToken.tokenOffset = (**theHTE).teLength+index+2; /* Past last char */
  4699.                 else
  4700.                     theTextToken.tokenOffset = index;
  4701.  
  4702.                 theTextToken.tokenLength = 0;
  4703.                 break;
  4704.  
  4705.             case cChar:
  4706.                 if (index<0)
  4707.                     theTextToken.tokenOffset = (**theHTE).teLength+index+1;
  4708.                 else
  4709.                   theTextToken.tokenOffset = index;
  4710.  
  4711.                 theTextToken.tokenLength = 1;
  4712.                 break;
  4713.  
  4714.             case cWord:
  4715.                 wordStartChar = 0;
  4716.                 wordLength    = (**theHTE).teLength;
  4717.                 GetWordInfo(index, theHTE, &wordStartChar, &wordLength); /* zero based */
  4718.                 theTextToken.tokenOffset = wordStartChar+1;
  4719.                 theTextToken.tokenLength = wordLength;
  4720.                 break;
  4721.  
  4722.             case cLine:
  4723.                 wordStartChar = 0;
  4724.                 wordLength    = (**theHTE).teLength;
  4725.                 GetLineInfo(index, theHTE, &wordStartChar, &wordLength); /* zero based */
  4726.                 theTextToken.tokenOffset = wordStartChar+1;
  4727.                 theTextToken.tokenLength = wordLength;
  4728.                 break;
  4729.             
  4730.             case cText:
  4731.                 theTextToken.tokenOffset = 1;
  4732.                 theTextToken.tokenLength = (**theHTE).teLength;
  4733.                 myErr                             = noErr;
  4734.                 break;
  4735.             }
  4736.             break;
  4737.  
  4738.         case formRange:
  4739.             /* coerce the selection data into an AERecord */
  4740.  
  4741.              myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  4742.  
  4743.             /* get the start object as a text token -
  4744.                     this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  4745.  
  4746.             myErr =
  4747.                 AEGetKeyPtr(
  4748.                     &selectionRecord,
  4749.                     keyAERangeStart,
  4750.                     typeMyText,
  4751.                     &returnedType,
  4752.                     (Ptr)&startText,
  4753.                     sizeof(startText),
  4754.                     &actSize);
  4755.  
  4756.             /* now do the same for the stop object */
  4757.             if (myErr==noErr)
  4758.                 myErr =
  4759.                     AEGetKeyPtr(
  4760.                         &selectionRecord,
  4761.                         keyAERangeStop,
  4762.                         typeMyText,
  4763.                         &returnedType,
  4764.                         (Ptr)&stopText,
  4765.                         sizeof(stopText),
  4766.                         &actSize);
  4767.  
  4768.             if (myErr==noErr)
  4769.                 if (
  4770.                     (theTextToken.tokenWindow != stopText.tokenWindow) ||
  4771.                     (theTextToken.tokenWindow != startText.tokenWindow)
  4772.                 )
  4773.                     myErr = errAECorruptData;    /* or whatever ????*/
  4774.  
  4775.             theTextToken.tokenOffset  = startText.tokenOffset;
  4776.             theTextToken.tokenLength  = stopText.tokenOffset + stopText.tokenLength - startText.tokenOffset;
  4777.  
  4778.             if (theTextToken.tokenLength<0)
  4779.                 myErr = errAECorruptData;    /* or whatever */
  4780.  
  4781.             ignoreErr = AEDisposeDesc(&selectionRecord);
  4782.  
  4783.             break;
  4784.         }
  4785.     }
  4786.  
  4787.     /* return theTextToken in a descriptor */
  4788.  
  4789.     if (myErr==noErr)
  4790.         myErr = AECreateDesc(typeMyText, (Ptr)&theTextToken, sizeof(theTextToken), value);
  4791.  
  4792.     return myErr;
  4793. }    /* TextElemFromWndwAccessor */
  4794.  
  4795. pascal OSErr TextElemFromWndwPropAccessor(
  4796.     DescType     wantClass,
  4797.     const AEDesc *container,
  4798.     DescType     containerClass,
  4799.     DescType     form,
  4800.     const AEDesc *selectionData,
  4801.     AEDesc       *value,
  4802.     long         theRefCon)
  4803. {
  4804. #if !defined(powerc) && !defined(__powerc)
  4805. #pragma unused (theRefCon, containerClass)
  4806. #endif
  4807.  
  4808.     OSErr               myErr;
  4809.     Size                actSize;
  4810.     long                index;
  4811.     AEDesc                windowPropDesc;
  4812.     windowPropToken     theWindowPropToken;
  4813.     TextToken           theTextToken;
  4814.     AERecord            selectionRecord;
  4815.     TextToken           startText;
  4816.     TextToken           stopText;
  4817.     DescType            returnedType;
  4818.     TEHandle            theHTE;
  4819.     short               wordStartChar;
  4820.     short               wordLength;
  4821.     DPtr                theDocument;
  4822.  
  4823.     myErr = -1700;    /* or whatever */
  4824.     windowPropDesc.dataHandle = nil;
  4825.     
  4826.     /* do some checking for robustness' sake */
  4827.  
  4828.     if (
  4829.         ((wantClass != cText) && (wantClass != cChar) && (wantClass != cSpot) && (wantClass != cLine) && (wantClass != cWord)) ||
  4830.         ((form != formAbsolutePosition) && (form != formRange))
  4831.     )
  4832.         return errAEWrongDataType;
  4833.  
  4834.     /* get the window property token*/
  4835.     myErr = AECoerceDesc(container, typeMyWindowProp, &windowPropDesc);
  4836.     GetRawDataFromDescriptor(&windowPropDesc, (Ptr)&theWindowPropToken, sizeof(theWindowPropToken), &actSize);
  4837.     if (windowPropDesc.dataHandle)
  4838.         AEDisposeDesc(&windowPropDesc);
  4839.  
  4840.     if (theWindowPropToken.tokenProperty != pSelection)
  4841.         return errAEEventNotHandled;
  4842.         
  4843.     /* let's get the src text */
  4844.     theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  4845.     theHTE      = theDocument->theText;
  4846.  
  4847.     theTextToken.tokenWindow     = theWindowPropToken.tokenWindowToken;
  4848.     theTextToken.tokenOffset    = (*theHTE)->selStart + 1;
  4849.     theTextToken.tokenLength    = (*theHTE)->selEnd - (*theHTE)->selStart;
  4850.  
  4851.     switch (form) {
  4852.     case formAbsolutePosition:
  4853.         myErr = GetLongIntFromDescriptor(selectionData, &index);
  4854.  
  4855.         switch (wantClass) {
  4856.         case cSpot:
  4857.             if (index<0)
  4858.                 theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  4859.             else
  4860.                 theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  4861.             theTextToken.tokenLength = 0;
  4862.             break;
  4863.  
  4864.         case cChar:
  4865.             if (index<0)
  4866.                 theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  4867.             else
  4868.                 theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  4869.             theTextToken.tokenLength = 1;
  4870.             break;
  4871.  
  4872.         case cWord:
  4873.             wordStartChar = theTextToken.tokenOffset-1;
  4874.             wordLength    = theTextToken.tokenLength;
  4875.  
  4876.             GetWordInfo(index, theHTE, &wordStartChar, &wordLength);/*zero based*/
  4877.  
  4878.             theTextToken.tokenOffset = wordStartChar+1;
  4879.             theTextToken.tokenLength = wordLength;
  4880.             break;
  4881.  
  4882.         case cLine:
  4883.             wordStartChar = theTextToken.tokenOffset-1;
  4884.             wordLength    = theTextToken.tokenLength;
  4885.  
  4886.             GetLineInfo(index, theHTE, &wordStartChar, &wordLength);
  4887.  
  4888.             theTextToken.tokenOffset = wordStartChar+1;
  4889.             theTextToken.tokenLength = wordLength;
  4890.             break;
  4891.         default: /* case cText */
  4892.             break;
  4893.         }
  4894.         break;
  4895.  
  4896.     case formRange:
  4897.         /* coerce the selection data into an AERecord */
  4898.  
  4899.          myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  4900.  
  4901.         /* get the start object as a text token -
  4902.                 this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  4903.  
  4904.         myErr =
  4905.             AEGetKeyPtr(
  4906.                 &selectionRecord,
  4907.                 keyAERangeStart,
  4908.                 typeMyText,
  4909.                 &returnedType,
  4910.                 (Ptr)&startText,
  4911.                 sizeof(startText),
  4912.                 &actSize);
  4913.  
  4914.         /* now do the same for the stop object */
  4915.  
  4916.         if (myErr==noErr)
  4917.             myErr =
  4918.                 AEGetKeyPtr(
  4919.                     &selectionRecord,
  4920.                     keyAERangeStop,
  4921.                     typeMyText,
  4922.                     &returnedType,
  4923.                     (Ptr)&stopText,
  4924.                     sizeof(stopText),
  4925.                     &actSize);
  4926.  
  4927.         if (myErr==noErr)
  4928.             if ((theTextToken.tokenWindow != stopText.tokenWindow) ||
  4929.                   (theTextToken.tokenWindow != startText.tokenWindow))
  4930.                 myErr = errAECorruptData;    /* or whatever */
  4931.  
  4932.         theTextToken.tokenOffset  = startText.tokenOffset;
  4933.         theTextToken.tokenLength  = stopText.tokenOffset + stopText.tokenLength - startText.tokenOffset;
  4934.  
  4935.         myErr = AEDisposeDesc(&selectionRecord);
  4936.         break;
  4937.     }
  4938.  
  4939.     /* return theTextToken in a descriptor */
  4940.  
  4941.     myErr =
  4942.         AECreateDesc(
  4943.             typeMyText,
  4944.             (Ptr)&theTextToken,
  4945.             sizeof(theTextToken),
  4946.             value);
  4947.  
  4948.     return myErr;
  4949. }    /* TextElemFromWndwPropAccessor */
  4950.  
  4951. pascal OSErr TextElemFromTextAccessor(
  4952.     DescType     wantClass,
  4953.     const AEDesc *container,
  4954.     DescType     containerClass,
  4955.     DescType     form,
  4956.     const AEDesc *selectionData,
  4957.     AEDesc       *value,
  4958.     long         theRefCon)
  4959. {
  4960. #if !defined(powerc) && !defined(__powerc)
  4961. #pragma unused (theRefCon, containerClass)
  4962. #endif
  4963.  
  4964.     OSErr       myErr;
  4965.     Size        actSize;
  4966.     long        index;
  4967.     TextToken   theTextToken;
  4968.     AERecord    selectionRecord;
  4969.     TextToken   startText;
  4970.     TextToken   stopText;
  4971.     DescType    returnedType;
  4972.     AEDesc      textDesc;
  4973.     TEHandle    theHTE;
  4974.     short       wordStartChar;
  4975.     short       wordLength;
  4976.     DPtr        theDocument;
  4977.  
  4978.     myErr = -1700;    /* or whatever */
  4979.  
  4980.     /* do some checking for robustness' sake */
  4981.  
  4982.     if (
  4983.         ((wantClass != cText) && (wantClass != cChar) && (wantClass != cSpot) && (wantClass != cLine) && (wantClass != cWord)) ||
  4984.         ((form != formAbsolutePosition) && (form != formRange))
  4985.     )
  4986.         return errAEWrongDataType;
  4987.  
  4988.     /* let's get the src text */
  4989.  
  4990.     myErr = AECoerceDesc(container, typeMyText, &textDesc);
  4991.     GetRawDataFromDescriptor(&textDesc, (Ptr)&theTextToken, sizeof(theTextToken), &actSize);
  4992.  
  4993.     myErr = AEDisposeDesc(&textDesc);
  4994.  
  4995.     theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  4996.     theHTE      = theDocument->theText;
  4997.  
  4998.     switch (form) {
  4999.     case formAbsolutePosition:
  5000.         myErr = GetLongIntFromDescriptor(selectionData, &index);
  5001.  
  5002.         switch (wantClass) {
  5003.         case cSpot:
  5004.             if (index<0)
  5005.                 theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  5006.             else
  5007.                 theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  5008.             theTextToken.tokenLength = 0;
  5009.             break;
  5010.  
  5011.         case cChar:
  5012.             if (index<0)
  5013.                 theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  5014.             else
  5015.                 theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  5016.             theTextToken.tokenLength = 1;
  5017.             break;
  5018.  
  5019.         case cWord:
  5020.             wordStartChar = theTextToken.tokenOffset-1;
  5021.             wordLength    = theTextToken.tokenLength;
  5022.  
  5023.             GetWordInfo(index, theHTE, &wordStartChar, &wordLength);/*zero based*/
  5024.  
  5025.             theTextToken.tokenOffset = wordStartChar+1;
  5026.             theTextToken.tokenLength = wordLength;
  5027.             break;
  5028.  
  5029.         case cLine:
  5030.             wordStartChar = theTextToken.tokenOffset-1;
  5031.             wordLength    = theTextToken.tokenLength;
  5032.  
  5033.             GetLineInfo(index, theHTE, &wordStartChar, &wordLength);
  5034.  
  5035.             theTextToken.tokenOffset = wordStartChar+1;
  5036.             theTextToken.tokenLength = wordLength;
  5037.             break;
  5038.         }
  5039.         break;
  5040.  
  5041.     case formRange:
  5042.         /* coerce the selection data into an AERecord */
  5043.  
  5044.          myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  5045.  
  5046.         /* get the start object as a text token -
  5047.                 this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  5048.  
  5049.         myErr =
  5050.             AEGetKeyPtr(
  5051.                 &selectionRecord,
  5052.                 keyAERangeStart,
  5053.                 typeMyText,
  5054.                 &returnedType,
  5055.                 (Ptr)&startText,
  5056.                 sizeof(startText),
  5057.                 &actSize);
  5058.  
  5059.         /* now do the same for the stop object */
  5060.  
  5061.         if (myErr==noErr)
  5062.             myErr =
  5063.                 AEGetKeyPtr(
  5064.                     &selectionRecord,
  5065.                     keyAERangeStop,
  5066.                     typeMyText,
  5067.                     &returnedType,
  5068.                     (Ptr)&stopText,
  5069.                     sizeof(stopText),
  5070.                     &actSize);
  5071.  
  5072.         if (myErr==noErr)
  5073.             if ((theTextToken.tokenWindow != stopText.tokenWindow) ||
  5074.                   (theTextToken.tokenWindow != startText.tokenWindow))
  5075.                 myErr = errAECorruptData;    /* or whatever */
  5076.  
  5077.         theTextToken.tokenOffset  = startText.tokenOffset;
  5078.         theTextToken.tokenLength  = stopText.tokenOffset + stopText.tokenLength - startText.tokenOffset;
  5079.  
  5080.         myErr = AEDisposeDesc(&selectionRecord);
  5081.         break;
  5082.     }
  5083.  
  5084.     /* return theTextToken in a descriptor */
  5085.  
  5086.     myErr =
  5087.         AECreateDesc(
  5088.             typeMyText,
  5089.             (Ptr)&theTextToken,
  5090.             sizeof(theTextToken),
  5091.             value);
  5092.  
  5093.     return myErr;
  5094. }    /* TextElemFromTextAccessor */
  5095.  
  5096. pascal OSErr PropertyFromTextAccessor(
  5097.     DescType     wantClass,
  5098.     const AEDesc *container,
  5099.     DescType     containerClass,
  5100.     DescType     form,
  5101.     const AEDesc *selectionData,
  5102.     AEDesc       *value,
  5103.     long         theRefCon)
  5104. {
  5105. #if !defined(powerc) && !defined(__powerc)
  5106. #pragma unused (theRefCon, containerClass)
  5107. #endif
  5108.  
  5109.     OSErr         myErr;
  5110.     OSErr         ignoreErr;
  5111.     TextToken     theTextToken;
  5112.     DescType      theProperty;
  5113.     AEDesc        textDesc;
  5114.     AEDesc        propDesc;
  5115.     Size          actualSize;
  5116.     textPropToken myTextProp;
  5117.  
  5118.     value->dataHandle   = nil;
  5119.     textDesc.dataHandle = nil;
  5120.     propDesc.dataHandle = nil;
  5121.  
  5122.     if ((wantClass != cProperty) || (form != formPropertyID)) {
  5123.         return errAEWrongDataType;
  5124.     }
  5125.  
  5126.     /* get the text token */
  5127.     myErr = AECoerceDesc(container, typeMyText, &textDesc);
  5128.     GetRawDataFromDescriptor(&textDesc, (Ptr)&theTextToken, sizeof(theTextToken), &actualSize);
  5129.  
  5130.     /* get the property */
  5131.     myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5132.     GetRawDataFromDescriptor(&propDesc, (Ptr)&theProperty, sizeof(theProperty), &actualSize);
  5133.  
  5134.     /*
  5135.         Combine the two into single token
  5136.     */
  5137.     myTextProp.propertyTextToken = theTextToken;
  5138.     myTextProp.propertyProperty  = theProperty;
  5139.  
  5140.     myErr = AECreateDesc(typeMyTextProp, (Ptr)&myTextProp, sizeof(myTextProp), value);
  5141.  
  5142.     if (textDesc.dataHandle)
  5143.         ignoreErr = AEDisposeDesc(&textDesc);
  5144.  
  5145.     if (propDesc.dataHandle)
  5146.         ignoreErr = AEDisposeDesc(&propDesc);
  5147.  
  5148.     return myErr;
  5149. }    /* PropertyFromTextAccessor */
  5150.  
  5151. pascal OSErr PropertyFromWndwAccessor(
  5152.     DescType     wantClass,
  5153.     const AEDesc *container,
  5154.     DescType     containerClass,
  5155.     DescType     form,
  5156.     const AEDesc *selectionData,
  5157.     AEDesc       *value,
  5158.     long         theRefCon)
  5159. {
  5160. #if !defined(powerc) && !defined(__powerc)
  5161. #pragma unused (theRefCon, containerClass)
  5162. #endif
  5163.  
  5164.     OSErr           myErr;
  5165.     OSErr           ignoreErr;
  5166.     WindowToken     theWindowToken;
  5167.     DescType        theProperty;
  5168.     AEDesc          windowDesc;
  5169.     AEDesc          propDesc;
  5170.     Size            actualSize;
  5171.     windowPropToken myWindowProp;
  5172.  
  5173.     value->dataHandle     = nil;
  5174.     windowDesc.dataHandle = nil;
  5175.     propDesc.dataHandle   = nil;
  5176.  
  5177.     if ((wantClass != cProperty) || (form != formPropertyID)) {
  5178.         return errAEWrongDataType;
  5179.     }
  5180.  
  5181.     /* get the window token - it's the container */
  5182.     myErr = AECoerceDesc(container, typeMyWndw, &windowDesc);
  5183.     GetRawDataFromDescriptor(&windowDesc, (Ptr)&theWindowToken, sizeof(theWindowToken), &actualSize);
  5184.  
  5185.     /* Check the window exists */
  5186.     if (theWindowToken==nil)
  5187.         myErr = errAEIllegalIndex;
  5188.     else {
  5189.  
  5190.         /* get the property - it's in the selection data */
  5191.  
  5192.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5193.         GetRawDataFromDescriptor(&propDesc, (Ptr)&theProperty, sizeof(theProperty), &actualSize);
  5194.  
  5195.         myWindowProp.tokenWindowToken = theWindowToken;
  5196.         myWindowProp.tokenProperty    = theProperty;
  5197.  
  5198.         myErr = AECreateDesc(typeMyWindowProp, (Ptr)&myWindowProp, sizeof(myWindowProp), value);
  5199.     }
  5200.  
  5201.     if (windowDesc.dataHandle)
  5202.         ignoreErr = AEDisposeDesc(&windowDesc);
  5203.  
  5204.     if (propDesc.dataHandle)
  5205.         ignoreErr = AEDisposeDesc(&propDesc);
  5206.  
  5207.     return myErr;
  5208. }    /* PropertyFromWndwAccessor */
  5209.  
  5210. pascal OSErr PropertyFromWndwPropAccessor(
  5211.     DescType     wantClass,
  5212.     const AEDesc *container,
  5213.     DescType     containerClass,
  5214.     DescType     form,
  5215.     const AEDesc *selectionData,
  5216.     AEDesc       *value,
  5217.     long         theRefCon)
  5218. {
  5219. #if !defined(powerc) && !defined(__powerc)
  5220. #pragma unused (theRefCon, containerClass)
  5221. #endif
  5222.  
  5223.     OSErr               myErr;
  5224.     OSErr               ignoreErr;
  5225.     windowPropToken     theWindowPropToken;
  5226.     textPropToken         myTextProp;
  5227.     DescType            theProperty;
  5228.     AEDesc              windowPropDesc;
  5229.     AEDesc              propDesc;
  5230.     Size                actualSize;
  5231.     TEHandle            theHTE;
  5232.     DPtr                theDocument;
  5233.  
  5234.     value->dataHandle             = nil;
  5235.     windowPropDesc.dataHandle     = nil;
  5236.     propDesc.dataHandle           = nil;
  5237.  
  5238.     if ((wantClass != cProperty) || (form != formPropertyID)) {
  5239.         return errAEWrongDataType;
  5240.     }
  5241.  
  5242.     /* get the window property token*/
  5243.     myErr = AECoerceDesc(container, typeMyWindowProp, &windowPropDesc);
  5244.     GetRawDataFromDescriptor(&windowPropDesc, (Ptr)&theWindowPropToken, sizeof(theWindowPropToken), &actualSize);
  5245.  
  5246.     /* get the property */
  5247.     myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5248.     GetRawDataFromDescriptor(&propDesc, (Ptr)&theProperty, sizeof(theProperty), &actualSize);
  5249.  
  5250.     if (theWindowPropToken.tokenProperty != pSelection)
  5251.         myErr = errAEEventNotHandled;
  5252.     else {
  5253.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  5254.         theHTE      = theDocument->theText;
  5255.         
  5256.         myTextProp.propertyTextToken.tokenWindow     = theWindowPropToken.tokenWindowToken;
  5257.         myTextProp.propertyTextToken.tokenOffset    = (*theHTE)->selStart + 1;
  5258.         myTextProp.propertyTextToken.tokenLength    = (*theHTE)->selEnd - (*theHTE)->selStart;
  5259.         myTextProp.propertyProperty                    = theProperty;
  5260.  
  5261.         myErr = AECreateDesc(typeMyTextProp, (Ptr)&myTextProp, sizeof(myTextProp), value);
  5262.     }
  5263.  
  5264.     if (windowPropDesc.dataHandle)
  5265.         ignoreErr = AEDisposeDesc(&windowPropDesc);
  5266.  
  5267.     if (propDesc.dataHandle)
  5268.         ignoreErr = AEDisposeDesc(&propDesc);
  5269.  
  5270.     return myErr;
  5271. }    /* PropertyFromWndwPropAccessor */
  5272.  
  5273. pascal OSErr PropertyFromNullAccessor(
  5274.     DescType     wantClass,
  5275.     const AEDesc *container,
  5276.     DescType     containerClass,
  5277.     DescType     form,
  5278.     const AEDesc *selectionData,
  5279.     AEDesc       *value,
  5280.     long         theRefCon)
  5281. {
  5282. #if !defined(powerc) && !defined(__powerc)
  5283. #pragma unused (theRefCon)
  5284. #endif
  5285.  
  5286.     OSErr                    myErr;
  5287.     OSErr                    ignoreErr;
  5288.     appToken                theApplToken;
  5289.     DescType                theProperty;
  5290.     AEDesc                applDesc;
  5291.     AEDesc                propDesc;
  5292.     Size                    actualSize;
  5293.     applPropToken        myApplProp;
  5294.     windowPropToken    myWindowProp;
  5295.     TEHandle                theHTE;
  5296.     DPtr                    theDocument;
  5297.  
  5298.     value->dataHandle     = nil;
  5299.     applDesc.dataHandle   = nil;
  5300.     propDesc.dataHandle   = nil;
  5301.  
  5302.     if ((wantClass != cProperty) || (form != formPropertyID)) {
  5303.         return errAEWrongDataType;
  5304.     }
  5305.  
  5306.     /* get the application token - it's the container */
  5307.     
  5308.     if (containerClass != typeNull) {
  5309.         myErr = AECoerceDesc(container, typeMyAppl, &applDesc);
  5310.         GetRawDataFromDescriptor(&applDesc, (Ptr)&theApplToken, sizeof(theApplToken), &actualSize);
  5311.     } else {
  5312.         theApplToken.highLongOfPSN = 0;
  5313.         theApplToken.lowLongOfPSN  = kCurrentProcess;
  5314.     }
  5315.     
  5316.     /* get the property - it's in the selection data */
  5317.  
  5318.     myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5319.     GetRawDataFromDescriptor(&propDesc, (Ptr)&theProperty, sizeof(theProperty), &actualSize);
  5320.  
  5321.     switch (theProperty) {
  5322.     case pUserSelection:
  5323.         theProperty = pSelection;
  5324.         /* Fall through */
  5325.     case pSelection:
  5326.         if (myWindowProp.tokenWindowToken = FrontWindow()) {
  5327.             myWindowProp.tokenProperty    = theProperty;
  5328.  
  5329.             myErr = AECreateDesc(typeMyWindowProp, (Ptr)&myWindowProp, sizeof(myWindowProp), value);
  5330.         } else
  5331.             myErr = errAEIllegalIndex;
  5332.             
  5333.         break;
  5334.     default:
  5335.         /*
  5336.             Combine the two into single token
  5337.         */
  5338.         myApplProp.tokenApplToken    = theApplToken;
  5339.         myApplProp.tokenApplProperty = theProperty;
  5340.     
  5341.         myErr = AECreateDesc(typeMyApplProp, (Ptr)&myApplProp, sizeof(myApplProp), value);
  5342.         break;
  5343.     }
  5344.     
  5345.     if (applDesc.dataHandle)
  5346.         ignoreErr = AEDisposeDesc(&applDesc);
  5347.  
  5348.     if (propDesc.dataHandle)
  5349.         ignoreErr = AEDisposeDesc(&propDesc);
  5350.  
  5351.     return myErr;
  5352. }    /* PropertyFromApplAccessor */
  5353.  
  5354. pascal OSErr MenuNameToMenuToken(const Str255 theName, MenuToken *theToken)
  5355. {
  5356.     short   index;
  5357.  
  5358.     for (index=appleM; index<kLastMenu; index++) {
  5359.         if (IUEqualString(theName, (**(myMenus[index])).menuData)==0) {
  5360.             theToken->theTokenMenu = myMenus[index];
  5361.             theToken->theTokenID   = index+appleID;
  5362.             return noErr;
  5363.         }
  5364.     }
  5365.     return errAEIllegalIndex;
  5366. }
  5367.  
  5368. pascal OSErr MenuFromNullAccessor(
  5369.     DescType      wantClass,
  5370.     const AEDesc  *container,
  5371.     DescType      containerClass,
  5372.     DescType      form,
  5373.     const AEDesc  *selectionData,
  5374.     AEDesc        *value,
  5375.     long          theRefCon)
  5376. {
  5377. #if !defined(powerc) && !defined(__powerc)
  5378. #pragma unused (container,theRefCon)
  5379. #endif
  5380.  
  5381.     OSErr       myErr;
  5382.     Str255      nameStr;
  5383.     MenuToken   theMenu;
  5384.     short       index;
  5385.     AEDesc      resultDesc;
  5386.  
  5387.     myErr = errAEBadKeyForm;    /* or whatever */
  5388.  
  5389.     value->dataHandle     = nil;
  5390.     resultDesc.dataHandle = nil;
  5391.  
  5392.     /*
  5393.         should only be called with wantClass = cMenu and
  5394.         with containerClass = typeNull or typeMyAppl.
  5395.         Currently accept as either formName or formAbsolutePosition
  5396.     */
  5397.  
  5398.     if (
  5399.         (wantClass != cMenu) ||
  5400.         ((containerClass != typeNull) && (containerClass != typeMyAppl)) ||
  5401.         !((form == formName) || (form == formAbsolutePosition))
  5402.     )
  5403.         return errAEWrongDataType;
  5404.  
  5405.     if (form == formName) {
  5406.         myErr = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  5407.         myErr = MenuNameToMenuToken(nameStr, &theMenu);
  5408.     }
  5409.  
  5410.     if (form == formAbsolutePosition) {
  5411.         myErr     = GetIntegerFromDescriptor(selectionData, &index);
  5412.         if (index<0)
  5413.             index = kLastMenu + index + 1;
  5414.  
  5415.         if (index>0 && index<kLastMenu+1) {
  5416.             theMenu.theTokenMenu = myMenus[index-1];
  5417.             theMenu.theTokenID   = index-1+appleID;
  5418.         } else
  5419.             myErr = errAEIllegalIndex;    /* or whatever */
  5420.     }
  5421.  
  5422.     if (myErr == noErr)
  5423.         myErr = AECreateDesc(typeMyMenu, (Ptr)&theMenu, sizeof(theMenu), value);
  5424.  
  5425.     return myErr;
  5426. }    /* MenuFromNullAccessor */
  5427.  
  5428. pascal OSErr PropertyFromMenuAccessor(
  5429.     DescType     wantClass,
  5430.     const AEDesc *container,
  5431.     DescType     containerClass,
  5432.     DescType     form,
  5433.     const AEDesc *selectionData,
  5434.     AEDesc       *value,
  5435.     long         theRefCon)
  5436. {
  5437. #if !defined(powerc) && !defined(__powerc)
  5438. #pragma unused (theRefCon, containerClass)
  5439. #endif
  5440.  
  5441.     OSErr         myErr;
  5442.     OSErr         ignoreErr;
  5443.     MenuToken     theMenuToken;
  5444.     DescType      theProperty;
  5445.     AEDesc        menuDesc;
  5446.     AEDesc        propDesc;
  5447.     Size          actualSize;
  5448.     MenuPropToken myMenuProp;
  5449.  
  5450.     value->dataHandle     = nil;
  5451.     menuDesc.dataHandle   = nil;
  5452.     propDesc.dataHandle   = nil;
  5453.  
  5454.     if ((wantClass != cProperty) || (form != formPropertyID)) {
  5455.         return errAEWrongDataType;
  5456.     }
  5457.  
  5458.     /* get the menu token - it's the container */
  5459.  
  5460.     myErr = AECoerceDesc(container, typeMyMenu, &menuDesc);
  5461.     GetRawDataFromDescriptor(&menuDesc, (Ptr)&theMenuToken, sizeof(theMenuToken), &actualSize);
  5462.  
  5463.     /* get the property - it's in the selection data */
  5464.  
  5465.     myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5466.     GetRawDataFromDescriptor(&propDesc, (Ptr)&theProperty, sizeof(theProperty), &actualSize);
  5467.  
  5468.     /*
  5469.         Combine the two into single token
  5470.     */
  5471.     myMenuProp.theMenuToken = theMenuToken;
  5472.     myMenuProp.theMenuProp  = theProperty;
  5473.  
  5474.     myErr = AECreateDesc(typeMyMenuProp, (Ptr)&myMenuProp, sizeof(myMenuProp), value);
  5475.  
  5476.     if (menuDesc.dataHandle)
  5477.         ignoreErr = AEDisposeDesc(&menuDesc);
  5478.  
  5479.     if (propDesc.dataHandle)
  5480.         ignoreErr = AEDisposeDesc(&propDesc);
  5481.  
  5482.     return myErr;
  5483. }    /* PropertyFromMenuAccessor */
  5484.  
  5485. pascal OSErr PropertyFromMenuItemAccessor(
  5486.     DescType     wantClass,
  5487.     const AEDesc *container,
  5488.     DescType     containerClass,
  5489.     DescType     form,
  5490.     const AEDesc *selectionData,
  5491.     AEDesc       *value,
  5492.     long         theRefCon)
  5493. {
  5494. #if !defined(powerc) && !defined(__powerc)
  5495. #pragma unused (theRefCon, containerClass)
  5496. #endif
  5497.  
  5498.     OSErr         myErr;
  5499.     OSErr         ignoreErr;
  5500.     MenuItemToken theMenuItemToken;
  5501.     DescType      theProperty;
  5502.     AEDesc        itemDesc;
  5503.     AEDesc        propDesc;
  5504.     Size          actualSize;
  5505.     MenuItemPropToken myItemProp;
  5506.  
  5507.     value->dataHandle     = nil;
  5508.     itemDesc.dataHandle   = nil;
  5509.     propDesc.dataHandle   = nil;
  5510.  
  5511.     if ((wantClass != cProperty) || (form != formPropertyID)) {
  5512.         return errAEWrongDataType;
  5513.     }
  5514.  
  5515.     /* get the menu token - it's the container */
  5516.  
  5517.     myErr = AECoerceDesc(container, typeMyMenuItem, &itemDesc);
  5518.     GetRawDataFromDescriptor(&itemDesc, (Ptr)&theMenuItemToken, sizeof(theMenuItemToken), &actualSize);
  5519.  
  5520.     /* get the property - it's in the selection data */
  5521.  
  5522.     myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5523.     GetRawDataFromDescriptor(&propDesc, (Ptr)&theProperty, sizeof(theProperty), &actualSize);
  5524.     /*
  5525.         Combine the two into single token
  5526.     */
  5527.     myItemProp.theItemToken  = theMenuItemToken;
  5528.     myItemProp.theItemProp   = theProperty;
  5529.  
  5530.     myErr = AECreateDesc(typeMyItemProp, (Ptr)&myItemProp, sizeof(myItemProp), value);
  5531.  
  5532.     if (itemDesc.dataHandle)
  5533.         ignoreErr = AEDisposeDesc(&itemDesc);
  5534.  
  5535.     if (propDesc.dataHandle)
  5536.         ignoreErr = AEDisposeDesc(&propDesc);
  5537.  
  5538.     return myErr;
  5539. }    /* PropertyFromMenuItemAccessor */
  5540.  
  5541. pascal OSErr ItemNameToItemIndex(const Str255 theName, MenuHandle theMenu, short *theIndex)
  5542. {
  5543.     short   index;
  5544.     short   maxItems;
  5545.     Str255  menuName;
  5546.  
  5547.     maxItems = CountMItems(theMenu);
  5548.  
  5549.     for (index=1; index<=maxItems; index++) {
  5550.         GetItem(theMenu, index, menuName);
  5551.         if (IUEqualString(theName, menuName)==0) {
  5552.             *theIndex = index;
  5553.             return noErr;
  5554.         }
  5555.     }
  5556.     return errAEIllegalIndex;
  5557. }
  5558.  
  5559. pascal OSErr MenuItemFromMenuAccessor(
  5560.     DescType     wantClass,
  5561.     const AEDesc *container,
  5562.     DescType     containerClass,
  5563.     DescType     form,
  5564.     const AEDesc *selectionData,
  5565.     AEDesc       *value,
  5566.     long         theRefCon)
  5567. {
  5568. #if !defined(powerc) && !defined(__powerc)
  5569. #pragma unused (theRefCon)
  5570. #endif
  5571.  
  5572.     OSErr         myErr;
  5573.     OSErr         ignoreErr;
  5574.     MenuItemToken theMenuItemToken;
  5575.     MenuToken     theMenuToken;
  5576.     AEDesc        menuDesc;
  5577.     Size          actualSize;
  5578.     Str255        nameStr;
  5579.     short         maxItems;
  5580.     short         index;
  5581.  
  5582.     value->dataHandle     = nil;
  5583.     menuDesc.dataHandle   = nil;
  5584.  
  5585.     if (
  5586.         (wantClass != cMenuItem) || (containerClass != cMenu) ||
  5587.         ((form != formAbsolutePosition) && (form != formName))
  5588.     ) {
  5589.         return errAEWrongDataType;
  5590.     }
  5591.  
  5592.     /* get the menu token - it's the container */
  5593.  
  5594.     myErr = AECoerceDesc(container, typeMyMenu, &menuDesc);
  5595.     GetRawDataFromDescriptor(&menuDesc, (Ptr)&theMenuToken, sizeof(theMenuToken), &actualSize);
  5596.  
  5597.     if (form==formAbsolutePosition) {
  5598.         myErr = GetIntegerFromDescriptor(selectionData, &index);
  5599.         maxItems = CountMItems(theMenuToken.theTokenMenu);
  5600.  
  5601.         if (index<0)
  5602.             index = maxItems + index + 1;
  5603.  
  5604.         if ((index<1) || (index>maxItems))
  5605.           myErr = errAEIllegalIndex;
  5606.     }
  5607.  
  5608.     if (form == formName) {
  5609.         myErr  = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  5610.         myErr  = ItemNameToItemIndex(nameStr, theMenuToken.theTokenMenu, &index);
  5611.     }
  5612.  
  5613.     /*
  5614.         Combine the two into single token
  5615.     */
  5616.  
  5617.     theMenuItemToken.theMenuToken  = theMenuToken;
  5618.     theMenuItemToken.theTokenItem  = index;
  5619.  
  5620.     if (myErr==noErr)
  5621.         myErr = AECreateDesc(typeMyMenuItem, (Ptr)&theMenuItemToken, sizeof(theMenuItemToken), value);
  5622.  
  5623.     if (menuDesc.dataHandle)
  5624.         ignoreErr = AEDisposeDesc(&menuDesc);
  5625.  
  5626.     return myErr;
  5627. }    /* MenuItemFromMenuAccessor */
  5628.  
  5629. /*******************************************************************************/
  5630. /*
  5631.     Stuff for counting objects
  5632. */
  5633.  
  5634. pascal OSErr MyCountProc(
  5635.     DescType     desiredType,
  5636.     DescType     containerClass,
  5637.     const AEDesc *container,
  5638.     long         *result)
  5639. /* so far all I count is:
  5640.   (1) the number of active windows in the app;
  5641.   (2) the number of words in a window
  5642. */
  5643. {
  5644.     OSErr       myErr;
  5645.     WindowToken theWindowToken;
  5646.     DPtr        theDocument;
  5647.     TEHandle    theHTE;
  5648.     AEDesc      newDesc;
  5649.     short       wordStart;
  5650.     short       wordLength;
  5651.     Size        tokenSize;
  5652.     TextToken   theTextToken;
  5653.  
  5654.     *result = -1;    /* easily recognized illegal value */
  5655.  
  5656.     myErr = errAEWrongDataType;
  5657.  
  5658.     if (desiredType == cWindow || desiredType == cDocument) {
  5659.         if ((containerClass == typeNull) || (containerClass == cApplication))
  5660.             *result = CountWindows();
  5661.     }
  5662.  
  5663.     if ((desiredType == cWord) || (desiredType == cLine) || (desiredType == cChar)) {
  5664.         myErr = AECoerceDesc(container, typeMyWndw, &newDesc);
  5665.         if (newDesc.descriptorType!=typeNull) {
  5666.                 GetRawDataFromDescriptor(
  5667.                     &newDesc,
  5668.                     (Ptr)&theWindowToken,
  5669.                     sizeof(theWindowToken),
  5670.                     &tokenSize);
  5671.  
  5672.                 myErr = AEDisposeDesc(&newDesc);
  5673.  
  5674.                 if (theWindowToken==nil)
  5675.                     myErr = errAEIllegalIndex;
  5676.                 else {
  5677.                     theDocument = DPtrFromWindowPtr(theWindowToken);
  5678.                     theHTE      = theDocument->theText;
  5679.  
  5680.                     if (desiredType == cWord) {
  5681.                         wordStart   = 0;
  5682.                         wordLength  = (**theHTE).teLength;
  5683.                         *result     = CountWords(theHTE, wordStart, wordLength);
  5684.                     }
  5685.  
  5686.                     if (desiredType == cChar)
  5687.                         *result = (**theHTE).teLength;
  5688.  
  5689.                     if (desiredType == cLine)
  5690.                         *result = CountLines(theHTE);
  5691.                 }
  5692.             }
  5693.  
  5694.         myErr = AECoerceDesc(container, typeMyText, &newDesc);
  5695.         if (newDesc.descriptorType!=typeNull) {
  5696.             GetRawDataFromDescriptor(
  5697.                 &newDesc,
  5698.                 (Ptr)&theTextToken,
  5699.                 sizeof(theTextToken),
  5700.                 &tokenSize);
  5701.  
  5702.             myErr = AEDisposeDesc(&newDesc);
  5703.  
  5704.             theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  5705.             theHTE      = theDocument->theText;
  5706.  
  5707.             if (desiredType == cWord) {
  5708.                 wordStart   = theTextToken.tokenOffset-1;
  5709.                 wordLength  = theTextToken.tokenLength;
  5710.                 *result     = CountWords(theHTE, wordStart, wordLength);
  5711.             }
  5712.  
  5713.             if (desiredType == cChar)
  5714.                 *result = theTextToken.tokenLength;
  5715.  
  5716.             if (desiredType == cLine)
  5717.                 *result    =
  5718.                     LineOfOffset(theHTE,theTextToken.tokenOffset-1) -
  5719.                     LineOfOffset(theHTE,theTextToken.tokenOffset+theTextToken.tokenLength-1)
  5720.                     +1;
  5721.         }
  5722.     }
  5723.  
  5724.     return myErr;
  5725. }    /* MyCountProc */
  5726.  
  5727. /*******************************************************************************/
  5728. /*
  5729.     Coercion Handlers - Allow AEResolve to do the hard work
  5730. */
  5731. pascal OSErr CoerceObjToAnything(
  5732.     const AEDesc *theAEDesc,
  5733.     DescType     toType,
  5734.     long         handlerRefCon,
  5735.     AEDesc       *result)
  5736. /*
  5737.     CoerceObjToAnything functions by using AEResolve to do the hard
  5738.     work.
  5739. */
  5740. {
  5741. #if !defined(powerc) && !defined(__powerc)
  5742. #pragma unused (handlerRefCon)
  5743. #endif
  5744.  
  5745.     OSErr  myErr;
  5746.     AEDesc objDesc;
  5747.  
  5748.     myErr = errAECoercionFail;
  5749.  
  5750.     result->dataHandle = nil;
  5751.     objDesc.dataHandle = nil;
  5752.  
  5753.  
  5754.     if (theAEDesc->descriptorType != typeObjectSpecifier) {
  5755.         return errAEWrongDataType;
  5756.     }
  5757.  
  5758.     /* resolve the object specifier */
  5759.     myErr = AEResolve(theAEDesc, kAEIDoMinimum, &objDesc);
  5760.  
  5761.     /* hopefully it's the right type by now, but we'll give it a nudge */
  5762.     if (myErr==noErr) {
  5763.         myErr = AECoerceDesc(&objDesc, toType, result);
  5764.         myErr = AEDisposeDesc(&objDesc);
  5765.     }
  5766.  
  5767.     if (result->descriptorType!=toType) {
  5768.         /*DebugStr('COTA - Not of requested type');*/
  5769.     }
  5770.  
  5771.     return myErr;
  5772. }    /* CoerceObjToAnything */
  5773.  
  5774. /*******************************************************************************/
  5775.  
  5776. /*----------------------------------------------------------------------------------------------*/
  5777.  
  5778. /*now for the edition manager event handling code*/
  5779.  
  5780. pascal OSErr GetHandleFromEvent(const AppleEvent *theAppleEvent, SectionHandle *sectionH)
  5781. {
  5782.     DescType ignoreType;
  5783.     Size          ignoreSize;
  5784.  
  5785.     return
  5786.         AEGetKeyPtr(
  5787.             theAppleEvent,
  5788.             keyDirectObject,
  5789.             typeSectionH,
  5790.             &ignoreType,
  5791.             (Ptr)sectionH,
  5792.             sizeof(SectionHandle),
  5793.             &ignoreSize);
  5794. } /* GetHandleFromEvent */
  5795.  
  5796. /*----------------------------------------------------------------------------------------------*/
  5797. pascal OSErr DoReadSection(const AppleEvent *theAppleEvent,AppleEvent *reply,long refCon)
  5798. {
  5799. #if !defined(powerc) && !defined(__powerc)
  5800. #pragma unused (reply, refCon)
  5801. #endif
  5802.  
  5803.     OSErr         err;
  5804.     SectionHandle sectionH;
  5805.  
  5806.     err = GetHandleFromEvent(theAppleEvent, §ionH);
  5807.     if (IsRegisteredSection(sectionH)==noErr)
  5808.         ReadAnEdition(sectionH);
  5809.     return err;
  5810. } /* DoReadSection */
  5811.  
  5812. /*----------------------------------------------------------------------------------------------*/
  5813. pascal OSErr DoWriteSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  5814. {
  5815. #if !defined(powerc) && !defined(__powerc)
  5816. #pragma unused (reply, refCon)
  5817. #endif
  5818.  
  5819.     OSErr         err;
  5820.     SectionHandle sectionH;
  5821.  
  5822.     err = GetHandleFromEvent(theAppleEvent, §ionH);
  5823.     if (IsRegisteredSection(sectionH) == noErr)
  5824.         WriteAnEdition(sectionH);
  5825.  
  5826.     return err;
  5827. } /* DoWriteSection */
  5828.  
  5829. /*----------------------------------------------------------------------------------------------*/
  5830. pascal OSErr DoScrollSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  5831. {
  5832. #if !defined(powerc) && !defined(__powerc)
  5833. #pragma unused (reply, refCon)
  5834. #endif
  5835.  
  5836.     OSErr         err;
  5837.     SectionHandle sectionH;
  5838.     SectHandle    aSectHandle;
  5839.  
  5840.     err = GetHandleFromEvent(theAppleEvent, §ionH);
  5841.     /*get at the sectHandle*/
  5842.     aSectHandle = (SectHandle)GetERefCon(sectionH);
  5843.     TESetSelect((**aSectHandle).fStart, (**aSectHandle).fEnd, ((**aSectHandle).fDocument)->theText);
  5844.     ShowSelect((**aSectHandle).fDocument);
  5845.     return err;
  5846. }
  5847.  
  5848. /*----------------------------------------------------------------------------------------------*/
  5849. pascal OSErr DoCancelSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  5850. {
  5851. #if !defined(powerc) && !defined(__powerc)
  5852. #pragma unused (reply, refCon)
  5853. #endif
  5854.  
  5855.     OSErr         err;
  5856.     SectionHandle sectionH;
  5857.     SectHandle    aSectHandle;
  5858.  
  5859.     err = GetHandleFromEvent(theAppleEvent, §ionH);
  5860.     aSectHandle = (SectHandle)GetERefCon(sectionH);
  5861.     err = UnRegisterSection(sectionH);
  5862.     DeleteASection(aSectHandle, (**aSectHandle).fDocument);
  5863.     return noErr;
  5864. } /* DoCancelSection */
  5865.  
  5866. #endif
  5867.  
  5868. pascal OSErr Text2FSSpec(
  5869.     DescType type, Ptr path, Size size, 
  5870.     DescType to, long refCon, AEDesc * result)
  5871. {
  5872.     OSErr            err;
  5873.     char            file[256];
  5874.     FSSpec        spec;
  5875.     CInfoPBRec    info;
  5876.     
  5877.     if (size > 255)
  5878.         return errAECoercionFail;
  5879.         
  5880.     memcpy(file, path, size);
  5881.     file[size] = 0;
  5882.     
  5883.     if (err = Path2FSSpec(file, &spec))
  5884.         return err;
  5885.     if (err = FSpCatInfo(&spec, &info))
  5886.         return err;
  5887.     
  5888.     return AECreateDesc(typeFSS, (Ptr) &spec, sizeof(FSSpec), result);
  5889. }
  5890.  
  5891. /* -----------------------------------------------------------------------
  5892.         Name:             InitAppleEvents
  5893.         Purpose:        Initialise the AppleEvent despatch table
  5894.      -----------------------------------------------------------------------**/
  5895.  
  5896. #if !defined(powerc) && !defined(__powerc)
  5897. #pragma segment Main
  5898. #endif
  5899.  
  5900. #define noRefCon -1
  5901.  
  5902. pascal void InitAppleEvents(void)
  5903. {
  5904.     OSErr aevtErr;
  5905.  
  5906.      gBigBrother = 0;
  5907.     gCharsInBuffer = 0;
  5908.     gTypingBuffer  = (char *)NewPtr(32000);
  5909.     gTypingTargetObject.dataHandle = 0;
  5910.  
  5911.     /*set up the dispatch table for the four standard apple events*/
  5912.  
  5913.     aevtErr = AEInstallEventHandler( kCoreEventClass, kAEOpenApplication, NewAEEventHandlerProc(DoOpenApp), noRefCon, false) ;
  5914.     aevtErr = AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments,   NewAEEventHandlerProc(DoOpenDocument), noRefCon, false) ;
  5915.     aevtErr = AEInstallEventHandler( kCoreEventClass, kAEPrintDocuments,  NewAEEventHandlerProc(DoPrintDocuments), noRefCon, false) ;
  5916.     aevtErr = AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, NewAEEventHandlerProc(MyQuit), noRefCon, false) ;
  5917.  
  5918. #ifndef RUNTIME
  5919.     aevtErr = AEInstallEventHandler( MPAppSig,           kAEOpenDocuments,   NewAEEventHandlerProc(DoOpenDocument), 1, false) ;
  5920.     aevtErr = AEInstallEventHandler( MPAppSig,           'DATA',                NewAEEventHandlerProc(Relay),              0, false) ;
  5921.  
  5922.     /* set up the dispatch table for the core AppleEvents for text */
  5923.  
  5924.     aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEDelete, NewAEEventHandlerProc(DoDeleteEdit),noRefCon, false);
  5925.  
  5926.     aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECut,    NewAEEventHandlerProc(DoCutEdit),   noRefCon, false);
  5927.     aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECopy,   NewAEEventHandlerProc(DoCopyEdit),  noRefCon, false);
  5928.     aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEPaste,  NewAEEventHandlerProc(DoPasteEdit), noRefCon, false);
  5929.     aevtErr = AEInstallEventHandler( kAECoreSuite,     kAESetData,NewAEEventHandlerProc(DoSetData),   noRefCon, false);
  5930.     aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEGetData,NewAEEventHandlerProc(DoGetData),   noRefCon, false);
  5931.     aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEGetDataSize,NewAEEventHandlerProc(DoGetDataSize),   noRefCon, false);
  5932.  
  5933.     aevtErr = AEInstallEventHandler( kAECoreSuite, kAECountElements,   NewAEEventHandlerProc(HandleNumberOfElements),   noRefCon, false);
  5934.     aevtErr = AEInstallEventHandler( kAECoreSuite, kAECreateElement,   NewAEEventHandlerProc(DoNewElement),   noRefCon, false);
  5935.     aevtErr = AEInstallEventHandler( kAECoreSuite, kAEDoObjectsExist,  NewAEEventHandlerProc(DoIsThereA),   noRefCon, false);
  5936.  
  5937.     aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEClose,  NewAEEventHandlerProc(DoCloseWindow),noRefCon, false);
  5938.     aevtErr = AEInstallEventHandler( kAECoreSuite,     kAESave,   NewAEEventHandlerProc(DoSaveWindow),noRefCon, false);
  5939.     aevtErr = AEInstallEventHandler( kAEMiscStandards, kAERevert, NewAEEventHandlerProc(DoRevertWindow),noRefCon, false);
  5940.  
  5941.     aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECreatePublisher,        NewAEEventHandlerProc(HandleCreatePub), noRefCon, false);
  5942.     aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEMakeObjectsVisible,     NewAEEventHandlerProc(HandleShowSelection),   noRefCon, false);
  5943.     aevtErr = AEInstallEventHandler( kAEMiscStandards, kAESelect,                     NewAEEventHandlerProc(HandleSelect),   noRefCon, false);
  5944.     aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEDoScript,               NewAEEventHandlerProc(DoScript), noRefCon, false);
  5945.  
  5946.     /* Now look for recording notifications */
  5947.  
  5948.     aevtErr = AEInstallEventHandler( kCoreEventClass, kAEStartedRecording, NewAEEventHandlerProc(HandleStartRecording), noRefCon, false);
  5949.     aevtErr = AEInstallEventHandler( kCoreEventClass, kAEStoppedRecording, NewAEEventHandlerProc(HandleStopRecording), noRefCon, false);
  5950.  
  5951.     /* Now Put in the required object accessors */
  5952.  
  5953.     aevtErr = AESetObjectCallbacks(nil,NewOSLCountProc(MyCountProc),nil,nil,nil,nil,nil);
  5954.  
  5955.  
  5956.     aevtErr = AEInstallObjectAccessor(cApplication, typeNull,   NewOSLAccessorProc(ApplicationFromNullAccessor),  0,false);
  5957.     aevtErr = AEInstallObjectAccessor(cProperty,    typeNull,     NewOSLAccessorProc(PropertyFromNullAccessor),0,false);
  5958.     aevtErr = AEInstallObjectAccessor(cProperty,    typeMyAppl, NewOSLAccessorProc(PropertyFromNullAccessor),0,false);
  5959.     aevtErr = AEInstallObjectAccessor(cWindow,      typeNull,   NewOSLAccessorProc(WindowFromNullAccessor),  0,false);
  5960.     aevtErr = AEInstallObjectAccessor(cWindow,        typeMyAppl, NewOSLAccessorProc(WindowFromNullAccessor),  0,false);
  5961.     aevtErr = AEInstallObjectAccessor(cDocument,    typeNull,   NewOSLAccessorProc(WindowFromNullAccessor),  0,false);
  5962.     aevtErr = AEInstallObjectAccessor(cDocument,        typeMyAppl, NewOSLAccessorProc(WindowFromNullAccessor),  0,false);
  5963.  
  5964.     aevtErr = AEInstallObjectAccessor(cProperty,        typeMyWndw,NewOSLAccessorProc(PropertyFromWndwAccessor),0,false);
  5965.     aevtErr = AEInstallObjectAccessor(cChar,            typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5966.     aevtErr = AEInstallObjectAccessor(cSpot,            typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5967.     aevtErr = AEInstallObjectAccessor(cWord,            typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5968.     aevtErr = AEInstallObjectAccessor(cLine,            typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5969.     aevtErr = AEInstallObjectAccessor(cText,            typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5970.  
  5971.     aevtErr = AEInstallObjectAccessor(cProperty,        typeMyWindowProp,NewOSLAccessorProc(PropertyFromWndwPropAccessor),0,false);
  5972.     aevtErr = AEInstallObjectAccessor(cChar,            typeMyWindowProp,NewOSLAccessorProc(TextElemFromWndwPropAccessor),0,false);
  5973.     aevtErr = AEInstallObjectAccessor(cSpot,            typeMyWindowProp,NewOSLAccessorProc(TextElemFromWndwPropAccessor),0,false);
  5974.     aevtErr = AEInstallObjectAccessor(cWord,            typeMyWindowProp,NewOSLAccessorProc(TextElemFromWndwPropAccessor),0,false);
  5975.     aevtErr = AEInstallObjectAccessor(cLine,            typeMyWindowProp,NewOSLAccessorProc(TextElemFromWndwPropAccessor),0,false);
  5976.     aevtErr = AEInstallObjectAccessor(cText,            typeMyWindowProp,NewOSLAccessorProc(TextElemFromWndwPropAccessor),0,false);
  5977.  
  5978.     aevtErr = AEInstallObjectAccessor(cProperty,        typeMyText,NewOSLAccessorProc(PropertyFromTextAccessor),0,false);
  5979.     aevtErr = AEInstallObjectAccessor(cChar,            typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5980.     aevtErr = AEInstallObjectAccessor(cWord,            typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5981.     aevtErr = AEInstallObjectAccessor(cSpot,            typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5982.     aevtErr = AEInstallObjectAccessor(cLine,            typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5983.     aevtErr = AEInstallObjectAccessor(cText,            typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5984.  
  5985.     aevtErr = AEInstallObjectAccessor(cMenu,            typeNull,       NewOSLAccessorProc(MenuFromNullAccessor),    0,false);
  5986.     aevtErr = AEInstallObjectAccessor(cProperty,        typeMyMenu,     NewOSLAccessorProc(PropertyFromMenuAccessor),0,false);
  5987.     aevtErr = AEInstallObjectAccessor(cProperty,        typeMyMenuItem, NewOSLAccessorProc(PropertyFromMenuItemAccessor),0,false);
  5988.     aevtErr = AEInstallObjectAccessor(cMenuItem,        typeMyMenu,     NewOSLAccessorProc(MenuItemFromMenuAccessor),0,false);
  5989.  
  5990.     /* Now the coercion handlers */
  5991.  
  5992.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyAppl,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5993.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyWndw,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5994.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyText,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5995.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyTextProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5996.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyWindowProp,(AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5997.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyApplProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5998.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenu,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5999.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  6000.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuItem,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  6001.     aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyItemProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  6002.  
  6003.     aevtErr = AEInstallCoercionHandler(typeChar,typeFSS,  (AECoercionHandlerUPP)NewAECoercePtrProc(Text2FSSpec),0,false,false);
  6004.         /*now install the appropriate edition manager events*/
  6005.  
  6006.     aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionReadMsgID,   NewAEEventHandlerProc(DoReadSection), noRefCon, false) ;
  6007.     aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionWriteMsgID,  NewAEEventHandlerProc(DoWriteSection), noRefCon, false) ;
  6008.     aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionScrollMsgID, NewAEEventHandlerProc(DoScrollSection), noRefCon, false) ;
  6009.     aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionCancelMsgID, NewAEEventHandlerProc(DoCancelSection), noRefCon, false) ;
  6010. #endif
  6011. } /* InitAppleEvents */
  6012.